From 796bb396c041b4cb4b6b4fa40d6c232c90ab279b Mon Sep 17 00:00:00 2001 From: Isala Piyarisi Date: Wed, 14 Jan 2026 23:27:00 +0530 Subject: [PATCH] Initial commit: ComfyUI Workflow API HTTP API for ComfyUI workflow submission with: - POST /api/webhook endpoint for workflow submission - Real-time progress events via callback URL - Automatic output collection (no re-encoding) - Input/Output nodes for webhook data access --- .gitignore | 50 +++ README.md | 202 +++++++++++ __init__.py | 77 ++++ core/__init__.py | 45 +++ core/client.py | 472 +++++++++++++++++++++++++ core/collector.py | 237 +++++++++++++ core/context.py | 198 +++++++++++ core/interceptor.py | 571 ++++++++++++++++++++++++++++++ core/types.py | 189 ++++++++++ example_client.py | 153 ++++++++ example_workflow.json | 95 +++++ nodes/__init__.py | 11 + nodes/receiver.py | 258 ++++++++++++++ nodes/send.py | 774 +++++++++++++++++++++++++++++++++++++++++ nodes/transformer.py | 581 +++++++++++++++++++++++++++++++ processors/__init__.py | 1 + processors/inputs.py | 746 +++++++++++++++++++++++++++++++++++++++ processors/outputs.py | 385 ++++++++++++++++++++ pytest.ini | 4 + requirements.txt | 18 + run_tests.py | 34 ++ sample_input.png | Bin 0 -> 388166 bytes server/__init__.py | 6 + server/routes.py | 308 ++++++++++++++++ server/uploads.py | 187 ++++++++++ tests/__init__.py | 0 tests/conftest.py | 7 + tests/test_core.py | 121 +++++++ utils/__init__.py | 16 + utils/files.py | 192 ++++++++++ utils/helpers.py | 30 ++ utils/mime.py | 141 ++++++++ utils/validation.py | 191 ++++++++++ 33 files changed, 6300 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 __init__.py create mode 100644 core/__init__.py create mode 100644 core/client.py create mode 100644 core/collector.py create mode 100644 core/context.py create mode 100644 core/interceptor.py create mode 100644 core/types.py create mode 100644 example_client.py create mode 100644 example_workflow.json create mode 100644 nodes/__init__.py create mode 100644 nodes/receiver.py create mode 100644 nodes/send.py create mode 100644 nodes/transformer.py create mode 100644 processors/__init__.py create mode 100644 processors/inputs.py create mode 100644 processors/outputs.py create mode 100644 pytest.ini create mode 100644 requirements.txt create mode 100644 run_tests.py create mode 100644 sample_input.png create mode 100644 server/__init__.py create mode 100644 server/routes.py create mode 100644 server/uploads.py create mode 100644 tests/__init__.py create mode 100644 tests/conftest.py create mode 100644 tests/test_core.py create mode 100644 utils/__init__.py create mode 100644 utils/files.py create mode 100644 utils/helpers.py create mode 100644 utils/mime.py create mode 100644 utils/validation.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3f73620 --- /dev/null +++ b/.gitignore @@ -0,0 +1,50 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg + +# Virtual environments +.env +.venv +env/ +venv/ +ENV/ + +# IDE +.idea/ +.vscode/ +*.swp +*.swo +*~ + +# Testing +.pytest_cache/ +.coverage +htmlcov/ +.tox/ +.nox/ + +# OS +.DS_Store +Thumbs.db + +# Project specific +outputs/ +*.log diff --git a/README.md b/README.md new file mode 100644 index 0000000..58a62ac --- /dev/null +++ b/README.md @@ -0,0 +1,202 @@ +# ComfyUI Workflow API + +HTTP API for ComfyUI with webhook-based workflow execution. Submit workflows via HTTP, receive real-time progress updates and outputs at your callback URL. + +## Installation + +```bash +cd /path/to/ComfyUI/custom_nodes +git clone https://github.com/isala404/comfy-workflow-api.git +pip install -r comfy-workflow-api/requirements.txt +``` + +## Use Cases + +- **Backend Integration**: Run ComfyUI as a headless service behind your application +- **Batch Processing**: Submit multiple workflows and receive results asynchronously +- **Distributed Systems**: Decouple workflow submission from result handling +- **Mobile/Web Apps**: Trigger image generation from any HTTP client + +## How It Works + +``` +Client ComfyUI Your Server + │ │ │ + ├─── POST /api/webhook ─────────►│ │ + │ (workflow + callback_url) │ │ + │ │ │ + │◄── {request_id, prompt_id} ────┤ │ + │ │ │ + │ ├── workflow.progress ──────────►│ + │ ├── workflow.progress ──────────►│ + │ ├── ... │ + │ │ │ + │ ├── multipart (files) ──────────►│ + │ │ │ +``` + +## Quick Start + +### 1. Create a workflow using webhook nodes + +Use **WebhookReceiver** → **WebhookTransformer** → **WebhookSend** to read inputs from HTTP and send outputs back: + +``` + ┌─► WebhookTransformer ──► CLIPTextEncode ──┐ +WebhookReceiver ────┤ (extracts "prompt") ├──► KSampler ──► WebhookSend + └─► WebhookTransformer ──► VAEEncode ───────┘ + (extracts "image") +``` + +### 2. Submit via HTTP + +```bash +# Image-to-image example +curl -X POST http://localhost:8188/api/webhook \ + -F "workflow=@workflow.json" \ + -F "callback_url=http://your-server.com/webhook" \ + -F "prompt=turn it into a watercolor painting" \ + -F "image=@input.png" +``` + +### 3. Receive at your callback + +Your server receives: +- **Progress events** (JSON): `{"event": "workflow.progress", "progress": {"value": 5, "max": 20}}` +- **Output files** (gzip multipart): Images, audio, video, etc. + +## Nodes + +### WebhookReceiver + +Entry point for webhook workflows. Reads request configuration from the HTTP call. + +| Output | Type | Description | +|--------|------|-------------| +| webhook_context | WEBHOOK_CONTEXT | Context for other webhook nodes | + +### WebhookTransformer + +Extracts a field from the HTTP request. Connects to any input type. + +| Input | Description | +|-------|-------------| +| webhook_context | From WebhookReceiver | +| field | Field name to extract (e.g., "prompt") | +| default_value | Optional fallback if field missing | + +| Output | Type | Description | +|--------|------|-------------| +| value | * (wildcard) | Extracted value, auto-typed | + +**Type inference**: Strings are converted to INT, FLOAT, BOOLEAN when applicable. File uploads become IMAGE, AUDIO, VIDEO, MESH, or LATENT based on content type. + +### WebhookSend + +Sends outputs to the callback URL. Supports 5 output fields. + +| Input | Description | +|-------|-------------| +| webhook_context | From WebhookReceiver | +| field_1..5 | Any ComfyUI type (IMAGE, AUDIO, STRING, etc.) | +| field_1..5_name | Names for each output | + +**Encoding**: IMAGE→PNG, AUDIO→FLAC, VIDEO→MP4, MESH→GLB, LATENT→safetensors + +## API Reference + +### POST /api/webhook + +| Field | Required | Description | +|-------|----------|-------------| +| workflow | Yes | Workflow JSON | +| callback_url | Yes | URL to receive events/outputs | +| auth_header | No | Auth header name | +| auth_value | No | Auth header value | +| timeout | No | HTTP timeout (default: 60s) | +| max_retries | No | Retry attempts (default: 3) | +| *custom fields* | No | Any field accessible via WebhookTransformer | + +**Response:** +```json +{"request_id": "...", "prompt_id": "...", "status": "queued"} +``` + +### GET /api/webhook/status/{request_id} + +Check request status. + +### DELETE /api/webhook/{request_id} + +Cancel a queued/running workflow. + +## Webhook Events + +| Event | Content-Type | Description | +|-------|--------------|-------------| +| workflow.started | application/json | Execution began | +| workflow.progress | application/json | Step progress (throttled 500ms) | +| workflow.completed | multipart/form-data (gzip) | Output files + metadata | +| workflow.error | application/json | Execution failed | + +**Note**: Completion payload is gzip compressed. Decompress before parsing. + +## Example + +**workflow.json** (see `example_workflow.json`): +```json +{ + "10": { + "class_type": "WebhookReceiver", + "inputs": {"debug": true} + }, + "11": { + "class_type": "WebhookTransformer", + "inputs": {"field": "prompt", "webhook_context": ["10", 0]} + }, + "6": { + "class_type": "CLIPTextEncode", + "inputs": {"text": ["11", 0], "clip": ["4", 1]} + }, + "...": "... rest of workflow ...", + "12": { + "class_type": "WebhookSend", + "inputs": {"webhook_context": ["10", 0], "field_1": ["8", 0]} + } +} +``` + +**Python client** (see `example_client.py`): +```python +import requests, json + +# Load image for img2img +image_data = open("input.png", "rb").read() + +response = requests.post( + "http://localhost:8188/api/webhook", + files={ + "workflow": (None, json.dumps(workflow), "application/json"), + "callback_url": (None, "http://localhost:5001/webhook"), + "prompt": (None, "make it look like a painting"), + "image": ("input.png", image_data, "image/png"), + } +) +``` + +## Testing + +```bash +# Terminal 1: Start ComfyUI +python main.py + +# Terminal 2: Run example client (image-to-image) +cd custom_nodes/comfy-workflow-api +python example_client.py sample_input.png "turn it into a watercolor painting" +``` + +A sample image (`sample_input.png`) is included in the repo for testing. + +## License + +MIT diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..5270cc6 --- /dev/null +++ b/__init__.py @@ -0,0 +1,77 @@ +""" +ComfyUI Workflow API - Server extension for workflow integration. + +Provides: +1. HTTP endpoint: POST /api/webhook for submitting workflows +2. WebhookReceiver node - Entry point for API-triggered workflows +3. WebhookTransformer node - Extract individual fields by name +4. WebhookSend node - Send outputs back to callback URL +5. Real-time progress updates via callback URL +""" + +__version__ = "1.0.0" + +import logging + +logger = logging.getLogger(__name__) + +# Import nodes +from .nodes.receiver import WebhookReceiver +from .nodes.transformer import WebhookTransformer +from .nodes.send import WebhookSend + +# Node mappings for ComfyUI +NODE_CLASS_MAPPINGS = { + "WebhookReceiver": WebhookReceiver, + "WebhookTransformer": WebhookTransformer, + "WebhookSend": WebhookSend, +} + +NODE_DISPLAY_NAME_MAPPINGS = { + "WebhookReceiver": "Workflow API Receiver", + "WebhookTransformer": "Workflow API Transformer", + "WebhookSend": "Workflow API Send", +} + +# Initialize server extension +_initialized = False + + +def _initialize(): + """Initialize server extension and interceptor hooks.""" + global _initialized + + if _initialized: + return + + try: + # Register HTTP routes + from .server.routes import register_routes + if register_routes(): + logger.info(f"[comfy-workflow-api] v{__version__} - Routes registered") + + # Install output interceptor for automatic webhook delivery + from .core.interceptor import install_output_interceptor + if install_output_interceptor(): + logger.info(f"[comfy-workflow-api] v{__version__} - Output interceptor installed") + + _initialized = True + logger.info(f"[comfy-workflow-api] v{__version__} loaded successfully") + + except Exception as e: + logger.error(f"[comfy-workflow-api] Failed to initialize: {e}", exc_info=True) + + +# Initialize on import +_initialize() + + +# Cleanup function +def _cleanup(): + """Cleanup on unload.""" + try: + from .core.interceptor import shutdown, uninstall_output_interceptor + uninstall_output_interceptor() + shutdown() + except Exception as e: + logger.warning(f"[comfy-workflow-api] Cleanup error: {e}") diff --git a/core/__init__.py b/core/__init__.py new file mode 100644 index 0000000..39fe0d0 --- /dev/null +++ b/core/__init__.py @@ -0,0 +1,45 @@ +"""Core components for webhook functionality.""" + +from .types import WebhookContext, WebhookEvent, WebhookResult, OutputInfo, WebhookField +from .context import ( + register_webhook_context, + get_webhook_context, + unregister_webhook_context, + get_all_contexts, + clear_all_contexts, + cleanup_old_contexts, + # Legacy aliases + register_context, + get_context, + get_context_by_prompt, + update_context, + unregister_context, +) +from .client import get_webhook_client, WebhookClient +from .collector import collect_outputs + +__all__ = [ + # Types + "WebhookContext", + "WebhookEvent", + "WebhookResult", + "OutputInfo", + "WebhookField", + # Context functions + "register_webhook_context", + "get_webhook_context", + "unregister_webhook_context", + "get_all_contexts", + "clear_all_contexts", + "cleanup_old_contexts", + # Legacy aliases + "register_context", + "get_context", + "get_context_by_prompt", + "update_context", + "unregister_context", + # Client + "get_webhook_client", + "WebhookClient", + "collect_outputs", +] diff --git a/core/client.py b/core/client.py new file mode 100644 index 0000000..1adfb53 --- /dev/null +++ b/core/client.py @@ -0,0 +1,472 @@ +""" +Production-grade async HTTP client for webhook delivery. +Supports multipart/form-data for file uploads with retry logic. +""" + +import asyncio +import gzip +import io +import json +import logging +import random +import time +from typing import Optional +from pathlib import Path + +import aiohttp + +from .types import WebhookResult + +logger = logging.getLogger(__name__) + +# Singleton client instance +_webhook_client: Optional["WebhookClient"] = None + + +def get_webhook_client() -> "WebhookClient": + """Get or create the singleton webhook client instance.""" + global _webhook_client + if _webhook_client is None: + _webhook_client = WebhookClient() + return _webhook_client + + +class WebhookClient: + """ + Production-grade async HTTP client for multipart webhook delivery. + + Features: + - Async HTTP with connection pooling + - Multipart/form-data support for file uploads + - Exponential backoff with jitter for retries + - Configurable timeout and retry settings + """ + + # Status codes that should trigger retry + RETRYABLE_STATUS_CODES = {408, 429, 500, 502, 503, 504} + + def __init__( + self, + timeout: float = 60.0, + max_retries: int = 3, + base_delay: float = 1.0, + max_delay: float = 60.0, + jitter_factor: float = 0.2, + max_connections: int = 10, + max_connections_per_host: int = 5, + ): + """ + Initialize the webhook client. + + Args: + timeout: Request timeout in seconds + max_retries: Maximum number of retry attempts + base_delay: Base delay for exponential backoff + max_delay: Maximum delay between retries + jitter_factor: Random jitter factor (0-1) + max_connections: Maximum total connections + max_connections_per_host: Maximum connections per host + """ + self._session: Optional[aiohttp.ClientSession] = None + self._session_loop: Optional[asyncio.AbstractEventLoop] = None + self.timeout = aiohttp.ClientTimeout(total=timeout) + self.max_retries = max_retries + self.base_delay = base_delay + self.max_delay = max_delay + self.jitter_factor = jitter_factor + self.max_connections = max_connections + self.max_connections_per_host = max_connections_per_host + + async def get_session(self) -> aiohttp.ClientSession: + """Get or create aiohttp session with connection pooling.""" + current_loop = asyncio.get_running_loop() + + # Create new session if none exists, if closed, or if event loop changed + if (self._session is None or + self._session.closed or + self._session_loop is not current_loop): + # Close old session if it exists and loop is still valid + if self._session and not self._session.closed: + try: + await self._session.close() + except Exception: + pass + + connector = aiohttp.TCPConnector( + limit=self.max_connections, + limit_per_host=self.max_connections_per_host, + keepalive_timeout=30, + enable_cleanup_closed=True, + ) + self._session = aiohttp.ClientSession( + connector=connector, + timeout=self.timeout, + ) + self._session_loop = current_loop + return self._session + + async def send_json( + self, + url: str, + payload: dict, + headers: Optional[dict] = None, + ) -> WebhookResult: + """ + Send JSON payload to webhook URL. + + Used for progress events, errors, and status updates. + + Args: + url: Webhook URL + payload: JSON-serializable dictionary + headers: Optional additional headers (e.g., auth) + + Returns: + WebhookResult with success status and details + """ + session = await self.get_session() + all_headers = {"Content-Type": "application/json"} + if headers: + all_headers.update(headers) + + return await self._execute_with_retry( + url=url, + session=session, + request_kwargs={"json": payload, "headers": all_headers} + ) + + async def send_multipart( + self, + url: str, + metadata: dict, + files: list[tuple[str, str, bytes, str]], + headers: Optional[dict] = None, + timeout: Optional[float] = None, + max_retries: Optional[int] = None, + compress: bool = False, + ) -> WebhookResult: + """ + Send multipart/form-data request with files. + + Args: + url: Webhook URL + metadata: JSON metadata dictionary + files: List of (field_name, filename, binary_data, mime_type) + headers: Optional additional headers (e.g., auth) + timeout: Optional request timeout (overrides default) + max_retries: Optional max retries (overrides default) + compress: If True, compress payload with gzip + + Returns: + WebhookResult with success status and details + """ + session = await self.get_session() + + if compress: + # Build compressed payload + return await self._send_multipart_compressed( + url=url, + session=session, + metadata=metadata, + files=files, + headers=headers, + timeout=timeout, + max_retries=max_retries, + ) + + def build_form(): + # Build FormData for each request (cannot reuse) + form = aiohttp.FormData() + + # Add metadata as JSON part + form.add_field( + "metadata", + json.dumps(metadata), + content_type="application/json", + ) + + # Add files + for name, filename, data, content_type in files: + form.add_field( + name, + data, + filename=filename, + content_type=content_type, + ) + return form + + return await self._execute_with_retry( + url=url, + session=session, + request_kwargs={"headers": headers}, + form_builder=build_form, + timeout=timeout, + max_retries=max_retries, + ) + + async def _send_multipart_compressed( + self, + url: str, + session: aiohttp.ClientSession, + metadata: dict, + files: list[tuple[str, str, bytes, str]], + headers: Optional[dict] = None, + timeout: Optional[float] = None, + max_retries: Optional[int] = None, + ) -> WebhookResult: + """ + Send gzip-compressed multipart/form-data request. + + Builds the multipart body, compresses it with gzip, and sends + with Content-Encoding: gzip header. + """ + import secrets + + def build_compressed_payload(): + # Generate a unique boundary + boundary = f"----WebhookBoundary{secrets.token_hex(16)}" + boundary_bytes = boundary.encode("utf-8") + + # Build multipart body manually + parts = [] + + # Add metadata part + parts.append(b"--" + boundary_bytes) + parts.append(b'Content-Disposition: form-data; name="metadata"') + parts.append(b"Content-Type: application/json") + parts.append(b"") + parts.append(json.dumps(metadata).encode("utf-8")) + + # Add file parts + for name, filename, data, content_type in files: + parts.append(b"--" + boundary_bytes) + disposition = f'Content-Disposition: form-data; name="{name}"; filename="{filename}"' + parts.append(disposition.encode("utf-8")) + parts.append(f"Content-Type: {content_type}".encode("utf-8")) + parts.append(b"") + parts.append(data) + + # Final boundary + parts.append(b"--" + boundary_bytes + b"--") + parts.append(b"") + + # Join with CRLF + body = b"\r\n".join(parts) + + # Compress with gzip + compressed = gzip.compress(body, compresslevel=6) + + return compressed, boundary + + compressed_data, boundary = build_compressed_payload() + + # Build headers + all_headers = { + "Content-Type": f"multipart/form-data; boundary={boundary}", + "Content-Encoding": "gzip", + "Content-Length": str(len(compressed_data)), + } + if headers: + all_headers.update(headers) + + return await self._execute_with_retry( + url=url, + session=session, + request_kwargs={"headers": all_headers, "data": compressed_data}, + timeout=timeout, + max_retries=max_retries, + ) + + async def send_multipart_streaming( + self, + url: str, + metadata: dict, + file_paths: list[tuple[str, str, str, str]], + headers: Optional[dict] = None, + ) -> WebhookResult: + """ + Send multipart request with files streamed from disk. + + Use this for large files (>50MB) to avoid memory issues. + + Args: + url: Webhook URL + metadata: JSON metadata dictionary + file_paths: List of (field_name, filename, file_path, mime_type) + headers: Optional additional headers (e.g., auth) + + Returns: + WebhookResult with success status and details + """ + session = await self.get_session() + + def build_writer(): + # Build multipart writer for streaming + writer = aiohttp.MultipartWriter("form-data") + + # Add metadata + metadata_payload = aiohttp.payload.JsonPayload(metadata) + metadata_payload.set_content_disposition("form-data", name="metadata") + writer.append_payload(metadata_payload) + + # Add files (streamed from disk) + for name, filename, path, content_type in file_paths: + file_path = Path(path) + if file_path.exists(): + with open(file_path, "rb") as f: + file_data = f.read() + payload = aiohttp.payload.BytesPayload( + file_data, + content_type=content_type, + ) + payload.set_content_disposition( + "form-data", name=name, filename=filename + ) + writer.append_payload(payload) + return writer + + return await self._execute_with_retry( + url=url, + session=session, + request_kwargs={"headers": headers}, + data_builder=build_writer + ) + + async def _execute_with_retry( + self, + url: str, + session: aiohttp.ClientSession, + request_kwargs: Optional[dict] = None, + form_builder=None, + data_builder=None, + timeout: Optional[float] = None, + max_retries: Optional[int] = None, + ) -> WebhookResult: + """ + Execute request with exponential backoff and jitter. + + Args: + url: Target URL + session: aiohttp session + request_kwargs: Additional kwargs for session.post() + form_builder: Function that returns FormData (for multipart) + data_builder: Function that returns MultipartWriter (for streaming) + timeout: Optional request timeout (overrides default) + max_retries: Optional max retries (overrides default) + + Returns: + WebhookResult with success status and details + """ + last_error = None + start_time = time.time() + retries = 0 + kwargs = request_kwargs or {} + + # Use instance defaults if not specified + effective_max_retries = max_retries if max_retries is not None else self.max_retries + + # Add timeout to kwargs if specified + if timeout is not None: + kwargs["timeout"] = aiohttp.ClientTimeout(total=timeout) + + for attempt in range(effective_max_retries + 1): + try: + if attempt > 0: + delay = self._calculate_delay(attempt) + logger.info( + f"Webhook retry {attempt}/{effective_max_retries} after {delay:.2f}s" + ) + await asyncio.sleep(delay) + retries = attempt + + # Build request data + post_kwargs = dict(kwargs) + if form_builder: + post_kwargs["data"] = form_builder() + elif data_builder: + post_kwargs["data"] = data_builder() + + # Make the request + response = await session.post(url, **post_kwargs) + try: + elapsed_ms = (time.time() - start_time) * 1000 + + if response.status < 400: + return WebhookResult( + success=True, + status=response.status, + elapsed_ms=elapsed_ms, + retries=retries, + ) + + # Check if retryable + if response.status in self.RETRYABLE_STATUS_CODES: + last_error = f"HTTP {response.status}" + logger.warning( + f"Webhook request failed with retryable status {response.status}" + ) + continue + + # Non-retryable error + body = await response.text() + return WebhookResult( + success=False, + status=response.status, + error=f"HTTP {response.status}: {body[:500]}", + elapsed_ms=elapsed_ms, + retries=retries, + ) + finally: + response.close() + + except aiohttp.ClientError as e: + last_error = f"Client error: {str(e)}" + logger.warning(f"Webhook client error: {e}") + continue + except asyncio.TimeoutError: + last_error = "Request timeout" + logger.warning("Webhook request timed out") + continue + except Exception as e: + last_error = f"Unexpected error: {str(e)}" + logger.error(f"Webhook unexpected error: {e}", exc_info=True) + continue + + elapsed_ms = (time.time() - start_time) * 1000 + return WebhookResult( + success=False, + error=last_error, + elapsed_ms=elapsed_ms, + retries=retries, + ) + + def _calculate_delay(self, attempt: int) -> float: + """ + Calculate retry delay with exponential backoff and jitter. + + Args: + attempt: Current attempt number (1-based) + + Returns: + Delay in seconds + """ + # Exponential backoff + delay = min(self.base_delay * (2 ** (attempt - 1)), self.max_delay) + # Add jitter + jitter = delay * self.jitter_factor * (random.random() * 2 - 1) + return max(0.1, delay + jitter) + + async def close(self): + """Close the HTTP session and release resources.""" + if self._session and not self._session.closed: + await self._session.close() + self._session = None + logger.debug("Webhook client session closed") + + +async def close_webhook_client(): + """Close the global webhook client instance.""" + global _webhook_client + if _webhook_client: + await _webhook_client.close() + _webhook_client = None diff --git a/core/collector.py b/core/collector.py new file mode 100644 index 0000000..7ca44a4 --- /dev/null +++ b/core/collector.py @@ -0,0 +1,237 @@ +""" +Output collector for webhook delivery. + +IMPORTANT: This collector does NOT re-encode outputs. +It reads the actual files saved by ComfyUI output nodes and sends them as-is. + +- User saves as WebP → WebP is sent +- User saves as FLAC → FLAC is sent +- User saves as GIF → GIF is sent + +Zero information loss, zero re-encoding overhead. +""" + +import logging +import os +from typing import Optional + +from .types import OutputInfo +from ..utils.mime import guess_mime_type +from ..utils.files import get_output_path, get_image_dimensions + +logger = logging.getLogger(__name__) + + +async def collect_outputs( + outputs: dict, + meta: Optional[dict] = None +) -> tuple[list[tuple[str, str, bytes, str]], list[dict]]: + """ + Collect all outputs from a workflow execution. + + This function reads the ACTUAL files saved by output nodes. + No re-encoding - files are sent exactly as saved. + + Args: + outputs: Dictionary mapping node_id -> UI output dict + e.g., {"9": {"images": [{"filename": "out.webp", ...}]}} + meta: Optional metadata dict mapping node_id -> node metadata + + Returns: + Tuple of: + - files: List of (field_name, filename, data, mime_type) tuples + - metadata: List of output info dicts for the metadata payload + """ + files = [] + metadata = [] + file_index = 0 + + for node_id, ui_output in outputs.items(): + if not ui_output or not isinstance(ui_output, dict): + continue + + # Get node type from metadata if available + node_type = None + if meta and node_id in meta: + node_meta = meta[node_id] + if isinstance(node_meta, dict): + node_type = node_meta.get("node_type") + + # Process all output keys generically + # ComfyUI uses: images, audio, video, gifs, 3d, latents, text, etc. + for output_key, items in ui_output.items(): + if not isinstance(items, list): + # Handle non-list outputs (e.g., text as tuple) + if output_key == "text": + text_content = _extract_text(items) + if text_content: + info = OutputInfo( + filename=f"text_{node_id}.txt", + mime_type="text/plain", + node_id=node_id, + node_type=node_type, + output_key=output_key, + file_size_bytes=len(text_content.encode("utf-8")), + ) + files.append(( + f"file_{file_index}", + info.filename, + text_content.encode("utf-8"), + info.mime_type, + )) + metadata.append(info.to_dict()) + file_index += 1 + continue + + # Process list of file references + for idx, item in enumerate(items): + if not isinstance(item, dict): + continue + + if "filename" not in item: + continue + + # This is a file reference + filename = item["filename"] + subfolder = item.get("subfolder", "") + folder_type = item.get("type", "output") + + # Get full path and read file + file_path = get_output_path(filename, subfolder, folder_type) + + if not os.path.exists(file_path): + logger.warning(f"Output file not found: {file_path}") + continue + + try: + with open(file_path, "rb") as f: + file_data = f.read() + except Exception as e: + logger.error(f"Failed to read output file {file_path}: {e}") + continue + + # Determine MIME type from actual filename + mime_type = guess_mime_type(filename) + + # Build output info + info = OutputInfo( + filename=filename, + mime_type=mime_type, + node_id=node_id, + node_type=node_type, + output_key=output_key, + file_size_bytes=len(file_data), + subfolder=subfolder if subfolder else None, + folder_type=folder_type, + ) + + # Add type-specific metadata + _enrich_output_info(info, file_path, file_data) + + # Add batch info if multiple items + if len(items) > 1: + info.batch_index = idx + info.batch_size = len(items) + + files.append(( + f"file_{file_index}", + filename, + file_data, + mime_type, + )) + metadata.append(info.to_dict()) + file_index += 1 + + logger.debug(f"Collected {len(files)} output files") + return files, metadata + + +def _extract_text(value) -> Optional[str]: + """Extract text content from various formats.""" + if isinstance(value, str): + return value + if isinstance(value, tuple) and len(value) > 0: + return str(value[0]) + if isinstance(value, list) and len(value) > 0: + return str(value[0]) + return None + + +def _enrich_output_info(info: OutputInfo, file_path: str, file_data: bytes): + """ + Add type-specific metadata to OutputInfo. + + This reads metadata from the file without modifying it. + """ + # Extract format from filename + if "." in info.filename: + info.format = info.filename.rsplit(".", 1)[1].lower() + + # Image dimensions + if info.mime_type.startswith("image/"): + try: + width, height = get_image_dimensions(file_path) + if width and height: + info.width = width + info.height = height + except Exception as e: + logger.debug(f"Could not get image dimensions: {e}") + + # Audio metadata + elif info.mime_type.startswith("audio/"): + try: + _extract_audio_metadata(info, file_data) + except Exception as e: + logger.debug(f"Could not get audio metadata: {e}") + + # Video metadata + elif info.mime_type.startswith("video/"): + try: + _extract_video_metadata(info, file_path) + except Exception as e: + logger.debug(f"Could not get video metadata: {e}") + + +def _extract_audio_metadata(info: OutputInfo, file_data: bytes): + """Extract audio metadata without decoding the full file.""" + # Simple detection based on file headers + if file_data[:4] == b"fLaC": + # FLAC - could parse header for sample rate + pass + elif file_data[:4] == b"RIFF": + # WAV - parse header + try: + import struct + if len(file_data) >= 44: + # Channels at offset 22 (2 bytes) + # Sample rate at offset 24 (4 bytes) + sample_rate = struct.unpack(" None: + """ + Register a webhook context for tracking. + + Args: + context: The WebhookContext to register + """ + with _lock: + if context.prompt_id: + _contexts[context.prompt_id] = context + context.start_time = datetime.now() + logger.debug( + f"Registered webhook context: prompt={context.prompt_id}, " + f"request={context.request_id}" + ) + else: + logger.warning("Cannot register context without prompt_id") + + +def get_webhook_context(prompt_id: str) -> Optional[WebhookContext]: + """ + Get a context by prompt ID. + + Args: + prompt_id: The ComfyUI prompt ID + + Returns: + The WebhookContext if found, None otherwise + """ + with _lock: + return _contexts.get(prompt_id) + + +def unregister_webhook_context(prompt_id: str) -> Optional[WebhookContext]: + """ + Remove and return a context from the registry. + + Args: + prompt_id: The prompt ID to unregister + + Returns: + The removed WebhookContext if found, None otherwise + """ + with _lock: + context = _contexts.pop(prompt_id, None) + if context: + logger.debug(f"Unregistered webhook context: {prompt_id}") + return context + + +def get_all_contexts() -> Dict[str, WebhookContext]: + """ + Get a copy of all registered contexts. + Useful for debugging and monitoring. + + Returns: + Dictionary mapping prompt_id to WebhookContext + """ + with _lock: + return dict(_contexts) + + +def clear_all_contexts() -> int: + """ + Clear all registered contexts. + Useful for testing and cleanup. + + Returns: + Number of contexts that were cleared + """ + with _lock: + count = len(_contexts) + _contexts.clear() + logger.debug(f"Cleared {count} webhook contexts") + return count + + +def cleanup_old_contexts(max_age_hours: int = 24) -> int: + """ + Remove old completed contexts. + + Args: + max_age_hours: Remove contexts older than this + + Returns: + Number of contexts removed + """ + cutoff = datetime.now() - timedelta(hours=max_age_hours) + count = 0 + + with _lock: + to_remove = [] + + for prompt_id, context in _contexts.items(): + # Clean up old contexts based on completed_at or start_time + if context.completed_at and context.completed_at < cutoff: + to_remove.append(prompt_id) + elif context.start_time and context.start_time < cutoff: + to_remove.append(prompt_id) + + for prompt_id in to_remove: + _contexts.pop(prompt_id, None) + count += 1 + + if count > 0: + logger.info(f"Cleaned up {count} old webhook contexts") + + return count + + +# Legacy function aliases for compatibility +def register_context(context: WebhookContext) -> None: + """Legacy alias for register_webhook_context.""" + register_webhook_context(context) + + +def get_context(request_id: str) -> Optional[WebhookContext]: + """ + Get a context by request ID (searches all contexts). + + Args: + request_id: The request ID to look up + + Returns: + The WebhookContext if found, None otherwise + """ + with _lock: + for context in _contexts.values(): + if context.request_id == request_id: + return context + return None + + +def get_context_by_prompt(prompt_id: str) -> Optional[WebhookContext]: + """Legacy alias for get_webhook_context.""" + return get_webhook_context(prompt_id) + + +def update_context(request_id: str, **kwargs) -> bool: + """ + Update fields on a context by request ID. + + Args: + request_id: The request ID to update + **kwargs: Fields to update + + Returns: + True if context was found and updated + """ + with _lock: + for context in _contexts.values(): + if context.request_id == request_id: + for key, value in kwargs.items(): + if hasattr(context, key): + setattr(context, key, value) + return True + return False + + +def unregister_context(request_id: str) -> Optional[WebhookContext]: + """ + Remove a context by request ID. + + Args: + request_id: The request ID to unregister + + Returns: + The removed WebhookContext if found, None otherwise + """ + with _lock: + to_remove = None + for prompt_id, context in _contexts.items(): + if context.request_id == request_id: + to_remove = prompt_id + break + + if to_remove: + return _contexts.pop(to_remove, None) + return None diff --git a/core/interceptor.py b/core/interceptor.py new file mode 100644 index 0000000..a5dada8 --- /dev/null +++ b/core/interceptor.py @@ -0,0 +1,571 @@ +"""Output interception system for webhook delivery and progress events.""" + +import logging +import traceback +import time +import asyncio +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime +from typing import Any, Callable, Optional +import uuid + +from .types import WebhookContext, WebhookEvent, OutputInfo +from .context import get_webhook_context, unregister_webhook_context +from .client import get_webhook_client + +logger = logging.getLogger(__name__) + +_original_task_done = None +_original_progress_hook = None +_interceptor_installed = False +_progress_hook_installed = False +_executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="webhook_") + +# Progress throttling - track last send time per prompt +_progress_last_sent: dict = {} +_PROGRESS_THROTTLE_MS = 500 # Minimum ms between progress updates + + +def install_output_interceptor() -> bool: + """Install the output interceptor into ComfyUI's execution system.""" + global _original_task_done, _interceptor_installed + if _interceptor_installed: + return True + try: + import execution + _original_task_done = execution.PromptQueue.task_done + execution.PromptQueue.task_done = _intercepted_task_done + _interceptor_installed = True + logger.info("Webhook output interceptor installed") + + # Also install progress hook + install_progress_hook() + + return True + except Exception as e: + logger.error(f"Failed to install output interceptor: {e}") + return False + + +def install_progress_hook() -> bool: + """Install progress hook by wrapping the ProgressBar class.""" + global _progress_hook_installed + + if _progress_hook_installed: + return True + + try: + import comfy.utils + + # Wrap the ProgressBar.update_absolute method to intercept progress + original_update = comfy.utils.ProgressBar.update_absolute + + def wrapped_update(self, value, total=None, preview=None): + # Call original first + result = original_update(self, value, total, preview) + + # Then forward to webhook if applicable + try: + _handle_progress_update(value, self.total, preview, self.node_id) + except Exception as e: + logger.debug(f"Progress webhook error: {e}") + + return result + + comfy.utils.ProgressBar.update_absolute = wrapped_update + _progress_hook_installed = True + + logger.info("Webhook progress hook installed") + return True + + except Exception as e: + logger.error(f"Failed to install progress hook: {e}") + return False + + +def _handle_progress_update(value, total, preview_image, node_id): + """Handle progress update and forward to webhooks.""" + global _progress_last_sent + + # Get the current prompt_id from ComfyUI's server + try: + from server import PromptServer + prompt_id = PromptServer.instance.last_prompt_id + except Exception: + return + + if not prompt_id: + return + + # Look up webhook context for this prompt + context = get_webhook_context(prompt_id) + if context is None or not context.callback_url or not context.send_progress: + return + + # Throttle progress updates + now_ms = time.time() * 1000 + last_sent = _progress_last_sent.get(prompt_id, 0) + + # Always send first and last updates + is_first = value <= 1 + is_last = value >= total + + if not is_first and not is_last: + if now_ms - last_sent < _PROGRESS_THROTTLE_MS: + return + + _progress_last_sent[prompt_id] = now_ms + + # Send progress event asynchronously + _executor.submit( + _send_progress_sync, + context.callback_url, + context.request_id, + prompt_id, + node_id or "unknown", + value, + total, + context.get_auth_headers() if hasattr(context, 'get_auth_headers') else {} + ) + + +def _webhook_progress_hook(value, total, preview_image=None, prompt_id=None, node_id=None): + """Legacy progress hook wrapper - kept for compatibility.""" + global _original_progress_hook, _progress_last_sent + + # Always call the original hook first (ComfyUI's websocket progress) + if _original_progress_hook is not None: + try: + _original_progress_hook(value, total, preview_image, prompt_id, node_id) + except Exception as e: + logger.warning(f"Original progress hook error: {e}") + + # Now handle webhook progress + if prompt_id is None: + return + + # Look up webhook context for this prompt + context = get_webhook_context(prompt_id) + if context is None or not context.callback_url or not context.send_progress: + return + + # Throttle progress updates + now_ms = time.time() * 1000 + last_sent = _progress_last_sent.get(prompt_id, 0) + + # Always send first (value=1) and last (value=total) updates + is_first = value == 1 or value == 0 + is_last = value >= total + + if not is_first and not is_last: + if now_ms - last_sent < _PROGRESS_THROTTLE_MS: + return + + _progress_last_sent[prompt_id] = now_ms + + # Send progress event asynchronously + _executor.submit( + _send_progress_sync, + context.callback_url, + context.request_id, + prompt_id, + node_id or "unknown", + value, + total, + context.get_auth_headers() if hasattr(context, 'get_auth_headers') else {} + ) + + +def _send_progress_sync(callback_url, request_id, prompt_id, node_id, value, total, headers): + """Send progress event synchronously (for thread pool).""" + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) + + try: + loop.run_until_complete( + _send_progress_async(callback_url, request_id, prompt_id, node_id, value, total, headers) + ) + except Exception as e: + logger.debug(f"Progress send error: {e}") + finally: + loop.close() + + +async def _send_progress_async(callback_url, request_id, prompt_id, node_id, value, total, headers): + """Send progress event to callback URL.""" + payload = { + "event": WebhookEvent.PROGRESS.value, + "request_id": request_id, + "prompt_id": prompt_id, + "timestamp": datetime.now().isoformat(), + "node_id": node_id, + "progress": { + "value": value, + "max": total + } + } + + try: + client = get_webhook_client() + result = await client.send_json( + url=callback_url, + payload=payload, + headers=headers + ) + + if result.success: + logger.debug(f"Progress {value}/{total} sent for {prompt_id}") + else: + logger.debug(f"Progress send failed: {result.error}") + + except Exception as e: + logger.debug(f"Progress send exception: {e}") + + +def uninstall_output_interceptor() -> bool: + """Uninstall the output interceptor.""" + global _original_task_done, _interceptor_installed + if not _interceptor_installed: + return True + try: + import execution + if _original_task_done is not None: + execution.PromptQueue.task_done = _original_task_done + _original_task_done = None + _interceptor_installed = False + return True + except Exception as e: + logger.error(f"Failed to uninstall output interceptor: {e}") + return False + + +def _intercepted_task_done(self, item_id: Any, history_result: dict, status: Any, process_item: Optional[Callable] = None): + """Intercepted task_done to send completion events.""" + global _original_task_done + + prompt_tuple = self.currently_running.get(item_id) + prompt_id = None + extra_data = {} + + if prompt_tuple: + prompt_id = prompt_tuple[1] if len(prompt_tuple) > 1 else None + extra_data = prompt_tuple[3] if len(prompt_tuple) > 3 else {} + + # Check if this is a webhook request (has webhook_config in extra_data) + webhook_config = extra_data.get("webhook_config") if isinstance(extra_data, dict) else None + + if webhook_config and prompt_id: + try: + outputs = history_result.get("outputs", {}) + meta = history_result.get("meta", {}) + + # Submit webhook delivery to thread pool + _executor.submit( + _send_webhook_completion_sync, + webhook_config, + prompt_id, + outputs, + meta, + status + ) + logger.debug(f"Webhook delivery queued for prompt {prompt_id}") + + except Exception as e: + logger.error(f"Failed to queue webhook send: {e}") + + # Call original task_done - MUST happen for ComfyUI to work correctly + if _original_task_done: + return _original_task_done(self, item_id, history_result, status, process_item) + + +def _send_webhook_completion_sync( + webhook_config: dict, + prompt_id: str, + outputs: dict, + meta: dict, + status: Any +): + """Send webhook completion in sync context (for thread pool).""" + import asyncio + + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) + + try: + loop.run_until_complete( + _send_webhook_completion(webhook_config, prompt_id, outputs, meta, status) + ) + except Exception as e: + logger.error(f"Webhook delivery failed for prompt {prompt_id}: {e}\n{traceback.format_exc()}") + finally: + loop.close() + + +async def _send_webhook_completion( + webhook_config: dict, + prompt_id: str, + outputs: dict, + meta: dict, + status: Any +): + """Send completion event with outputs to callback URL.""" + from ..processors.outputs import ( + process_outputs_for_webhook, + load_output_file, + enrich_output_info + ) + + callback_url = webhook_config.get("callback_url") + if not callback_url: + logger.debug(f"No callback_url in webhook_config for prompt {prompt_id}") + return + + request_id = webhook_config.get("request_id", str(uuid.uuid4())) + start_time = datetime.now() + + try: + # Process all outputs from all nodes + all_outputs = process_outputs_for_webhook(outputs, meta) + + if not all_outputs: + all_outputs = [] + + # Enrich outputs with dimensions, file sizes + for output in all_outputs: + try: + enrich_output_info(output) + except Exception as e: + logger.warning(f"Failed to enrich output {output.filename}: {e}") + + # Build files list for multipart + files = [] + output_metadata = [] + + for idx, output in enumerate(all_outputs): + output_metadata.append(output.to_dict()) + + if output.filename: + try: + file_data = load_output_file(output) + if file_data: + files.append(( + f"file_{idx}", + output.filename, + file_data, + output.mime_type or "application/octet-stream" + )) + except Exception as e: + logger.warning(f"Failed to load output file {output.filename}: {e}") + + # Extract status information + status_str = "unknown" + status_messages = [] + if status is not None: + if hasattr(status, "status_str"): + status_str = status.status_str + elif hasattr(status, "_asdict"): + status_dict = status._asdict() + status_str = status_dict.get("status_str", "unknown") + status_messages = status_dict.get("messages", []) + + # Calculate execution time from context if available + execution_time_ms = None + context = get_webhook_context(prompt_id) + if context and context.start_time: + execution_time_ms = (datetime.now() - context.start_time).total_seconds() * 1000 + + # Build metadata payload + event_type = WebhookEvent.COMPLETED.value if status_str == "success" else WebhookEvent.ERROR.value + metadata = { + "event": event_type, + "request_id": request_id, + "prompt_id": prompt_id, + "timestamp": datetime.now().isoformat(), + "status": status_str, + "outputs": output_metadata, + "output_count": len(all_outputs), + "file_count": len(files), + "execution_time_ms": execution_time_ms, + "nodes_executed": len(outputs), + } + + if status_messages: + metadata["messages"] = status_messages + + # Get auth headers + headers = _get_auth_headers(webhook_config) + + # Send the webhook + client = get_webhook_client() + + if files: + result = await client.send_multipart( + url=callback_url, + metadata=metadata, + files=files, + headers=headers + ) + else: + result = await client.send_json( + url=callback_url, + payload=metadata, + headers=headers + ) + + if result.success: + logger.info( + f"Webhook delivered for prompt {prompt_id}: " + f"{len(files)} files, {len(output_metadata)} outputs, " + f"status={result.status}, {result.elapsed_ms:.0f}ms" + ) + else: + logger.error( + f"Webhook failed for prompt {prompt_id}: " + f"status={result.status}, error={result.error}" + ) + + except Exception as e: + logger.error(f"Error sending webhook for prompt {prompt_id}: {e}\n{traceback.format_exc()}") + + finally: + # Clean up context + try: + unregister_webhook_context(prompt_id) + except Exception: + pass + + +def _get_auth_headers(webhook_config: dict) -> dict: + """Build authentication headers from webhook config.""" + headers = {} + + auth_header = webhook_config.get("auth_header") + auth_value = webhook_config.get("auth_value") + + if auth_header and auth_value: + headers[auth_header] = auth_value + + custom_headers = webhook_config.get("headers") + if isinstance(custom_headers, dict): + headers.update(custom_headers) + + return headers + + +async def send_progress_event( + context: WebhookContext, + node_id: str, + node_type: str, + progress: float, + message: str = "" +): + """Send a progress event to the callback URL.""" + if not context.send_progress or not context.callback_url: + return + + elapsed_ms = None + if context.start_time: + elapsed_ms = (datetime.now() - context.start_time).total_seconds() * 1000 + + payload = { + "event": WebhookEvent.PROGRESS.value, + "request_id": context.request_id, + "prompt_id": context.prompt_id, + "timestamp": datetime.now().isoformat(), + "node_id": node_id, + "node_type": node_type, + "progress": progress, + "message": message, + "elapsed_ms": elapsed_ms, + } + + try: + client = get_webhook_client() + result = await client.send_json( + url=context.callback_url, + payload=payload, + headers=context.get_auth_headers() + ) + + if not result.success: + logger.warning(f"Progress event failed: {result.error}") + + except Exception as e: + logger.warning(f"Failed to send progress event: {e}") + + +async def send_started_event(context: WebhookContext): + """Send workflow started event.""" + if not context.callback_url: + return + + payload = { + "event": WebhookEvent.STARTED.value, + "request_id": context.request_id, + "prompt_id": context.prompt_id, + "timestamp": datetime.now().isoformat(), + } + + try: + client = get_webhook_client() + await client.send_json( + url=context.callback_url, + payload=payload, + headers=context.get_auth_headers() + ) + except Exception as e: + logger.warning(f"Failed to send started event: {e}") + + +async def send_error_event( + context: WebhookContext, + error_type: str, + error_message: str, + node_id: Optional[str] = None, + node_type: Optional[str] = None, + traceback_str: Optional[str] = None +): + """Send workflow error event.""" + if not context.callback_url: + return + + elapsed_ms = None + if context.start_time: + elapsed_ms = (datetime.now() - context.start_time).total_seconds() * 1000 + + payload = { + "event": WebhookEvent.ERROR.value, + "request_id": context.request_id, + "prompt_id": context.prompt_id, + "timestamp": datetime.now().isoformat(), + "error": { + "type": error_type, + "message": error_message, + "node_id": node_id, + "node_type": node_type, + }, + "elapsed_ms": elapsed_ms, + } + + if traceback_str: + payload["error"]["traceback"] = traceback_str[:2000] + + try: + client = get_webhook_client() + await client.send_json( + url=context.callback_url, + payload=payload, + headers=context.get_auth_headers() + ) + except Exception as e: + logger.warning(f"Failed to send error event: {e}") + + +def shutdown(): + """Shutdown the webhook executor gracefully.""" + global _executor + try: + _executor.shutdown(wait=True, cancel_futures=False) + logger.info("Webhook executor shut down") + except Exception as e: + logger.warning(f"Error shutting down webhook executor: {e}") diff --git a/core/types.py b/core/types.py new file mode 100644 index 0000000..ac09792 --- /dev/null +++ b/core/types.py @@ -0,0 +1,189 @@ +"""Core data types for webhook functionality.""" + +from dataclasses import dataclass, field +from enum import Enum +from typing import Any, Dict, Optional +from datetime import datetime +import uuid + + +class WebhookEvent(Enum): + """Types of webhook events.""" + STARTED = "workflow.started" + PROGRESS = "workflow.progress" + COMPLETED = "workflow.completed" + ERROR = "workflow.error" + INTERRUPTED = "workflow.interrupted" + + +@dataclass +class WebhookField: + """Individual field from webhook request.""" + name: str + value: Any + is_file: bool = False + filename: Optional[str] = None + content_type: Optional[str] = None + size_bytes: Optional[int] = None + + +@dataclass +class WebhookContext: + """ + Context for a webhook request. + + Tracks the entire lifecycle of a webhook request from submission + through execution and completion. + """ + # Callback configuration + callback_url: str = "" + auth_header: Optional[str] = None + auth_value: Optional[str] = None + timeout: int = 60 + max_retries: int = 3 + + # Identity + request_id: str = field(default_factory=lambda: str(uuid.uuid4())) + prompt_id: Optional[str] = None + + # Parsed webhook fields + fields: Dict[str, WebhookField] = field(default_factory=dict) + + # Raw inputs for fallback + inputs: dict = field(default_factory=dict) + + # Progress settings + send_progress: bool = True + progress_interval_ms: int = 500 + + # Request metadata + remote_ip: Optional[str] = None + content_type: Optional[str] = None + content_length: Optional[int] = None + user_agent: Optional[str] = None + + # Workflow settings + include_workflow_in_response: bool = False + + # Timestamps + timestamp: datetime = field(default_factory=datetime.now) + start_time: Optional[datetime] = None + completed_at: Optional[datetime] = None + + def get_auth_headers(self) -> dict: + """Get authentication headers for HTTP requests.""" + if self.auth_header and self.auth_value: + return {self.auth_header: self.auth_value} + return {} + + def censor_auth(self) -> str: + """Get censored auth header for logging.""" + if self.auth_header and self.auth_value: + value = self.auth_value + if len(value) > 12: + censored = value[:4] + "*" * (len(value) - 8) + value[-4:] + else: + censored = "*" * len(value) + return f"{self.auth_header}: {censored}" + return "(not set)" + + def has_field(self, name: str) -> bool: + """Check if a field exists.""" + return name in self.fields or name in self.inputs + + def get_field(self, name: str) -> Optional[WebhookField]: + """Get a WebhookField by name.""" + return self.fields.get(name) + + def get_field_value(self, name: str, default: Any = None) -> Any: + """Get a field's value.""" + if name in self.fields: + return self.fields[name].value + if name in self.inputs: + return self.inputs[name] + return default + + def get_field_names(self) -> list: + """Get all field names.""" + names = set(self.fields.keys()) + names.update(self.inputs.keys()) + return sorted(names) + + def to_dict(self) -> dict: + """Convert to dictionary for serialization.""" + return { + "request_id": self.request_id, + "prompt_id": self.prompt_id, + "callback_url": self.callback_url, + "fields": list(self.fields.keys()), + "timestamp": self.timestamp.isoformat() if self.timestamp else None, + } + + +@dataclass +class WebhookResult: + """Result of a webhook HTTP request.""" + success: bool + status: Optional[int] = None + error: Optional[str] = None + response_body: Optional[str] = None + elapsed_ms: float = 0.0 + retries: int = 0 + + +@dataclass +class OutputInfo: + """Information about a collected output file.""" + # Required fields + type: str = "UNKNOWN" + filename: str = "" + mime_type: str = "application/octet-stream" + + # File info + file_size_bytes: Optional[int] = None + + # Source info (for automatic collection) + node_id: Optional[str] = None + node_type: Optional[str] = None + output_key: Optional[str] = None + subfolder: Optional[str] = None + folder_type: str = "output" + + # Type-specific metadata + width: Optional[int] = None + height: Optional[int] = None + channels: Optional[int] = None + dtype: Optional[str] = None + format: Optional[str] = None + + # Audio/Video metadata + duration_seconds: Optional[float] = None + sample_rate: Optional[int] = None + frame_count: Optional[int] = None + fps: Optional[float] = None + + # Batch info + batch_index: Optional[int] = None + batch_size: Optional[int] = None + + # Inline content for small text + inline_content: Optional[str] = None + + def to_dict(self) -> dict: + """Convert to dictionary for metadata payload.""" + result = { + "type": self.type, + "filename": self.filename, + "mime_type": self.mime_type, + } + + # Add optional fields if present + for key in ["file_size_bytes", "node_id", "node_type", "output_key", + "width", "height", "channels", "dtype", "format", + "duration_seconds", "sample_rate", "frame_count", "fps", + "batch_index", "batch_size", "inline_content"]: + val = getattr(self, key) + if val is not None: + result[key] = val + + return result diff --git a/example_client.py b/example_client.py new file mode 100644 index 0000000..63ddf76 --- /dev/null +++ b/example_client.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python3 +""" +Example client for comfy-workflow-api (Image-to-Image). + +Submits an image + prompt to ComfyUI and receives the transformed image via webhook. + +Usage: + python example_client.py [prompt] + +Examples: + python example_client.py input.png "make it look like a painting" + python example_client.py photo.jpg "add snow to the scene" + +Requirements: + pip install requests + +Make sure ComfyUI is running on http://localhost:8188 +""" + +import gzip +import json +import sys +import threading +from http.server import HTTPServer, BaseHTTPRequestHandler +from pathlib import Path + +import requests + +# Configuration +COMFYUI_URL = "http://localhost:8188" +CALLBACK_PORT = 5001 +OUTPUT_DIR = Path("./outputs") +WORKFLOW_FILE = Path(__file__).parent / "example_workflow.json" + + +class WebhookHandler(BaseHTTPRequestHandler): + """Handles webhook callbacks from ComfyUI.""" + + files_received = [] + done = threading.Event() + + def log_message(self, *args): + pass # Suppress logging + + def do_POST(self): + content_type = self.headers.get("Content-Type", "") + content_encoding = self.headers.get("Content-Encoding", "") + length = int(self.headers.get("Content-Length", 0)) + body = self.rfile.read(length) + + # Decompress gzip if needed (WebhookSend uses gzip compression) + if "gzip" in content_encoding: + body = gzip.decompress(body) + + if "application/json" in content_type: + data = json.loads(body) + event = data.get("event") + + if event == "workflow.progress": + progress = data.get("progress", {}) + print(f" Progress: {progress.get('value')}/{progress.get('max')}") + elif event == "workflow.completed": + print(f" Completed in {data.get('execution_time_ms', 'N/A')}ms") + elif event == "workflow.error": + print(f" Error: {data.get('error')}") + WebhookHandler.done.set() + + elif "multipart" in content_type: + # Parse multipart and save files + boundary = content_type.split("boundary=")[1] + parts = body.split(f"--{boundary}".encode()) + + OUTPUT_DIR.mkdir(exist_ok=True) + + for part in parts: + if b"filename=" in part and b"\r\n\r\n" in part: + header, content = part.split(b"\r\n\r\n", 1) + filename = header.decode().split('filename="')[1].split('"')[0] + content = content.rstrip(b"\r\n--") + + path = OUTPUT_DIR / filename + path.write_bytes(content) + WebhookHandler.files_received.append(str(path)) + print(f" Saved: {path}") + + WebhookHandler.done.set() + + self.send_response(200) + self.end_headers() + self.wfile.write(b"OK") + + +def main(): + if len(sys.argv) < 2: + print("Usage: python example_client.py [prompt]") + print("Example: python example_client.py input.png \"make it look like a painting\"") + sys.exit(1) + + image_path = Path(sys.argv[1]) + if not image_path.exists(): + print(f"Error: Image not found: {image_path}") + sys.exit(1) + + prompt = " ".join(sys.argv[2:]) if len(sys.argv) > 2 else "enhance the image" + + print(f"Image: {image_path}") + print(f"Prompt: {prompt}") + print(f"Output: {OUTPUT_DIR.absolute()}\n") + + # Load workflow + workflow = json.loads(WORKFLOW_FILE.read_text()) + + # Load image + image_data = image_path.read_bytes() + image_mime = "image/png" if image_path.suffix.lower() == ".png" else "image/jpeg" + + # Start webhook server + server = HTTPServer(("localhost", CALLBACK_PORT), WebhookHandler) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + + callback_url = f"http://localhost:{CALLBACK_PORT}/webhook" + + # Submit workflow with image and prompt + print("Submitting workflow...") + response = requests.post( + f"{COMFYUI_URL}/api/webhook", + files={ + "workflow": (None, json.dumps(workflow), "application/json"), + "callback_url": (None, callback_url), + "prompt": (None, prompt), + "image": (image_path.name, image_data, image_mime), + } + ) + + result = response.json() + print(f" Request ID: {result.get('request_id')}") + print(f" Prompt ID: {result.get('prompt_id')}\n") + + # Wait for completion + print("Processing...") + WebhookHandler.done.wait(timeout=300) + + server.shutdown() + + if WebhookHandler.files_received: + print(f"\nDone! Files saved to {OUTPUT_DIR.absolute()}") + else: + print("\nNo files received.") + + +if __name__ == "__main__": + main() diff --git a/example_workflow.json b/example_workflow.json new file mode 100644 index 0000000..627ac76 --- /dev/null +++ b/example_workflow.json @@ -0,0 +1,95 @@ +{ + "3": { + "inputs": { + "seed": 798343486140665, + "steps": 20, + "cfg": 7, + "sampler_name": "euler", + "scheduler": "normal", + "denoise": 0.7, + "model": ["4", 0], + "positive": ["6", 0], + "negative": ["7", 0], + "latent_image": ["5", 0] + }, + "class_type": "KSampler", + "_meta": {"title": "KSampler"} + }, + "4": { + "inputs": { + "ckpt_name": "v1-5-pruned-emaonly-fp16.safetensors" + }, + "class_type": "CheckpointLoaderSimple", + "_meta": {"title": "Load Checkpoint"} + }, + "5": { + "inputs": { + "pixels": ["13", 0], + "vae": ["4", 2] + }, + "class_type": "VAEEncode", + "_meta": {"title": "VAE Encode"} + }, + "6": { + "inputs": { + "text": ["11", 0], + "clip": ["4", 1] + }, + "class_type": "CLIPTextEncode", + "_meta": {"title": "CLIP Text Encode (Prompt)"} + }, + "7": { + "inputs": { + "text": "text, watermark, blurry, low quality", + "clip": ["4", 1] + }, + "class_type": "CLIPTextEncode", + "_meta": {"title": "CLIP Text Encode (Negative)"} + }, + "8": { + "inputs": { + "samples": ["3", 0], + "vae": ["4", 2] + }, + "class_type": "VAEDecode", + "_meta": {"title": "VAE Decode"} + }, + "10": { + "inputs": { + "default_callback_url": "", + "default_timeout": 60, + "default_max_retries": 3, + "debug": true + }, + "class_type": "WebhookReceiver", + "_meta": {"title": "Webhook Receiver"} + }, + "11": { + "inputs": { + "field": "prompt", + "debug": true, + "webhook_context": ["10", 0] + }, + "class_type": "WebhookTransformer", + "_meta": {"title": "Extract Prompt"} + }, + "12": { + "inputs": { + "field_1_name": "output", + "debug": false, + "webhook_context": ["10", 0], + "field_1": ["8", 0] + }, + "class_type": "WebhookSend", + "_meta": {"title": "Webhook Send"} + }, + "13": { + "inputs": { + "field": "image", + "debug": true, + "webhook_context": ["10", 0] + }, + "class_type": "WebhookTransformer", + "_meta": {"title": "Extract Image"} + } +} diff --git a/nodes/__init__.py b/nodes/__init__.py new file mode 100644 index 0000000..ce73547 --- /dev/null +++ b/nodes/__init__.py @@ -0,0 +1,11 @@ +"""ComfyUI nodes for webhook integration.""" + +from .receiver import WebhookReceiver +from .transformer import WebhookTransformer +from .send import WebhookSend + +__all__ = [ + "WebhookReceiver", + "WebhookTransformer", + "WebhookSend", +] diff --git a/nodes/receiver.py b/nodes/receiver.py new file mode 100644 index 0000000..e70887b --- /dev/null +++ b/nodes/receiver.py @@ -0,0 +1,258 @@ +"""WebhookReceiver node - Entry point for webhook-triggered workflows.""" + +import asyncio +import logging +import uuid +from datetime import datetime +from typing import Any, Dict + +from ..core.types import WebhookContext, WebhookField +from ..core.context import register_webhook_context +from ..core.interceptor import send_started_event +from ..utils.helpers import format_size + +logger = logging.getLogger(__name__) + + +class WebhookReceiver: + """ + Entry point for webhook-triggered workflows. + + Extracts webhook configuration from extra_pnginfo (passed from /api/webhook) + and creates a WebhookContext for use by downstream nodes. + + Configuration comes from webhook_config in extra_pnginfo: + - callback_url: Where to send results + - auth_header: Auth header name (e.g., "Authorization") + - auth_value: Auth header value (e.g., "Bearer token123") + - request_id: Unique request identifier + - timeout: HTTP timeout + - max_retries: Retry attempts + + Fields/uploads come from webhook_inputs in extra_pnginfo. + """ + + @classmethod + def INPUT_TYPES(cls): + return { + "required": {}, + "optional": { + "default_callback_url": ("STRING", { + "default": "", + "tooltip": "Fallback callback URL if not provided in request" + }), + "default_timeout": ("INT", { + "default": 60, + "min": 1, + "max": 300, + "tooltip": "HTTP request timeout in seconds" + }), + "default_max_retries": ("INT", { + "default": 3, + "min": 0, + "max": 10, + "tooltip": "Number of retry attempts on failure" + }), + "debug": ("BOOLEAN", { + "default": False, + "tooltip": "Enable debug logging" + }), + }, + "hidden": { + "prompt": "PROMPT", + "extra_pnginfo": "EXTRA_PNGINFO", + "unique_id": "UNIQUE_ID", + }, + } + + RETURN_TYPES = ("WEBHOOK_CONTEXT",) + RETURN_NAMES = ("webhook_context",) + FUNCTION = "receive" + CATEGORY = "webhook" + DESCRIPTION = "Entry point for webhook-triggered workflows. Extracts webhook config and creates context for downstream nodes." + + @classmethod + def IS_CHANGED(cls, **kwargs): + """Always return a unique value to prevent caching.""" + # Webhook requests should never be cached as each request has unique data + import uuid + return str(uuid.uuid4()) + + def receive( + self, + prompt=None, + extra_pnginfo=None, + unique_id=None, + default_callback_url="", + default_timeout=60, + default_max_retries=3, + debug=False, + ): + """ + Extract webhook configuration and create context. + + The context is registered for output interception and passed + to WebhookTransformer nodes for field extraction. + """ + # Extract webhook_config and webhook_inputs from extra_data + extra_data = extra_pnginfo or {} + webhook_config = extra_data.get("webhook_config", {}) + webhook_inputs = extra_data.get("webhook_inputs", {}) + + # Extract configuration from webhook_config + callback_url = webhook_config.get("callback_url") or default_callback_url + auth_header = webhook_config.get("auth_header") + auth_value = webhook_config.get("auth_value") + request_id = webhook_config.get("request_id") or str(uuid.uuid4()) + timeout = webhook_config.get("timeout") or default_timeout + max_retries = webhook_config.get("max_retries") or default_max_retries + + # Extract request metadata + remote_ip = webhook_config.get("remote_ip", "unknown") + content_type = webhook_config.get("content_type", "multipart/form-data") + content_length = webhook_config.get("content_length") + user_agent = webhook_config.get("user_agent", "unknown") + + # Build fields dictionary from webhook_inputs + fields: Dict[str, WebhookField] = {} + for name, value in webhook_inputs.items(): + # Skip reserved fields that start with _ + if name.startswith("_"): + continue + + # Detect if this is a file upload (has special structure) + is_file = False + filename = None + content_type_field = None + size_bytes = None + + if isinstance(value, dict) and value.get("_is_file"): + # This is a file upload - load from saved path + is_file = True + filename = value.get("_filename") + content_type_field = value.get("_content_type") + size_bytes = value.get("_size_bytes", 0) + saved_path = value.get("_saved_path") + + # Load file data from disk + if saved_path: + try: + from pathlib import Path + value = Path(saved_path).read_bytes() + except Exception as e: + logger.warning(f"Failed to load file from {saved_path}: {e}") + value = b"" + else: + value = b"" + elif isinstance(value, bytes): + # Raw bytes = file + is_file = True + size_bytes = len(value) + elif isinstance(value, str): + size_bytes = len(value.encode("utf-8")) + + fields[name] = WebhookField( + name=name, + value=value, + is_file=is_file, + filename=filename, + content_type=content_type_field, + size_bytes=size_bytes, + ) + + # Create context + context = WebhookContext( + callback_url=callback_url, + request_id=request_id, + auth_header=auth_header, + auth_value=auth_value, + timeout=timeout, + max_retries=max_retries, + fields=fields, + remote_ip=remote_ip, + content_type=content_type, + content_length=content_length, + user_agent=user_agent, + prompt_id=unique_id, + inputs=webhook_inputs, # Raw inputs for fallback + send_progress=webhook_config.get("send_progress", True), + progress_interval_ms=webhook_config.get("progress_interval_ms", 500), + include_workflow_in_response=webhook_config.get("include_workflow_in_response", False), + ) + + # Debug output + if debug: + self._print_debug(context, fields) + + # Register context for output interception + if context.prompt_id: + register_webhook_context(context) + if not debug: + logger.info( + f"WebhookReceiver: Registered context for prompt {context.prompt_id}, " + f"callback: {callback_url or '(none)'}, " + f"fields: {list(fields.keys())}" + ) + + # Send started event if callback URL is configured + if context.callback_url: + try: + # Try to get running loop (Python 3.10+ safe) + loop = asyncio.get_running_loop() + asyncio.create_task(send_started_event(context)) + except RuntimeError: + # No running loop - run synchronously + try: + asyncio.run(send_started_event(context)) + except RuntimeError: + # Fallback for nested event loops + from ..utils.helpers import run_async + run_async(send_started_event(context)) + except Exception as e: + logger.warning(f"Failed to send started event: {e}") + + return (context,) + + def _print_debug(self, context: WebhookContext, fields: Dict[str, WebhookField]): + """Print debug information about the incoming request.""" + timestamp = context.timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" + + lines = [ + "", + "[Webhook Receiver] Incoming Request", + "=" * 50, + f" Remote IP: {context.remote_ip or 'unknown'}", + f" Timestamp: {timestamp}", + f" Request ID: {context.request_id}", + f" Content-Type: {context.content_type or 'unknown'}", + f" Content-Length: {format_size(context.content_length)}", + f" User-Agent: {context.user_agent or 'unknown'}", + "", + " Configuration:", + f" Callback URL: {context.callback_url or '(none)'}", + f" Auth Header: {context.censor_auth()}", + f" Timeout: {context.timeout}s", + f" Max Retries: {context.max_retries}", + "", + f" Fields Received ({len(fields)}):", + ] + + if fields: + field_names = sorted(fields.keys()) + for i, name in enumerate(field_names): + field = fields[name] + prefix = " +-" if i == len(field_names) - 1 else " |-" + + if field.is_file: + size_str = format_size(field.size_bytes) + ct = field.content_type or "application/octet-stream" + lines.append(f"{prefix} {name:20} (file) {ct}, {size_str}") + else: + size_str = format_size(field.size_bytes) + lines.append(f"{prefix} {name:20} (text) {size_str}") + else: + lines.append(" (no fields)") + + lines.append("=" * 50) + + print("\n".join(lines)) diff --git a/nodes/send.py b/nodes/send.py new file mode 100644 index 0000000..be85b77 --- /dev/null +++ b/nodes/send.py @@ -0,0 +1,774 @@ +"""WebhookSend node - Send workflow outputs to callback URL.""" + +import io +import json +import logging +import struct +from datetime import datetime +from typing import Optional, Any, Dict, List, Tuple, Union + +import numpy as np +import torch +from PIL import Image + +from ..core.types import WebhookContext, WebhookResult, OutputInfo +from ..core.client import get_webhook_client +from ..utils.helpers import format_size, run_async + +logger = logging.getLogger(__name__) + + +class WebhookSend: + """ + Send workflow outputs to the callback URL as multipart/form-data. + + Supports 5 customizable wildcard fields. Each field accepts any + ComfyUI type (IMAGE, AUDIO, VIDEO, MESH, LATENT, MASK, STRING, etc.) + and automatically encodes it appropriately. + + Field Encoding: + - IMAGE: PNG file + - AUDIO: FLAC file + - VIDEO: MP4 file + - MESH: GLB file + - LATENT: Safetensors file + - MASK: PNG file (grayscale) + - STRING: Text part + - INT/FLOAT/BOOLEAN: Text part + + Always includes a metadata JSON field with request info. + Payload is always gzip compressed (Content-Encoding: gzip). + """ + + @classmethod + def INPUT_TYPES(cls): + return { + "required": { + "webhook_context": ("WEBHOOK_CONTEXT",), + }, + "optional": { + # Field 1 + "field_1": ("*", {"tooltip": "First output (any type)"}), + "field_1_name": ("STRING", { + "default": "output_1", + "tooltip": "Field name for first output" + }), + # Field 2 + "field_2": ("*", {"tooltip": "Second output (any type)"}), + "field_2_name": ("STRING", { + "default": "output_2", + "tooltip": "Field name for second output" + }), + # Field 3 + "field_3": ("*", {"tooltip": "Third output (any type)"}), + "field_3_name": ("STRING", { + "default": "output_3", + "tooltip": "Field name for third output" + }), + # Field 4 + "field_4": ("*", {"tooltip": "Fourth output (any type)"}), + "field_4_name": ("STRING", { + "default": "output_4", + "tooltip": "Field name for fourth output" + }), + # Field 5 + "field_5": ("*", {"tooltip": "Fifth output (any type)"}), + "field_5_name": ("STRING", { + "default": "output_5", + "tooltip": "Field name for fifth output" + }), + # Debug + "debug": ("BOOLEAN", { + "default": False, + "tooltip": "Enable debug logging" + }), + # Batch outputs + "batch_outputs": ("BOOLEAN", { + "default": False, + "tooltip": "Send all items in batched outputs (images/masks). Field names become prefixes with _0, _1, etc. suffixes." + }), + }, + } + + RETURN_TYPES = () + OUTPUT_NODE = True + FUNCTION = "send" + CATEGORY = "webhook" + DESCRIPTION = "Send workflow outputs to callback URL as gzip-compressed multipart/form-data. Supports 5 customizable wildcard fields." + + def send( + self, + webhook_context, + field_1=None, + field_1_name="output_1", + field_2=None, + field_2_name="output_2", + field_3=None, + field_3_name="output_3", + field_4=None, + field_4_name="output_4", + field_5=None, + field_5_name="output_5", + debug=False, + batch_outputs=False, + ): + if not isinstance(webhook_context, WebhookContext): + logger.warning("WebhookSend: Invalid webhook context") + return {} + + if not webhook_context.callback_url: + logger.warning("WebhookSend: No callback URL configured") + return {} + + # Collect non-None fields + fields_to_send = [] + for field, name in [ + (field_1, field_1_name), + (field_2, field_2_name), + (field_3, field_3_name), + (field_4, field_4_name), + (field_5, field_5_name), + ]: + if field is not None: + fields_to_send.append((name, field)) + + try: + result = run_async( + self._send_async(webhook_context, fields_to_send, debug, batch_outputs) + ) + return {} + except Exception as e: + logger.error(f"WebhookSend failed: {e}", exc_info=True) + if debug: + self._print_error(webhook_context, str(e)) + return {} + + async def _send_async( + self, + context: WebhookContext, + fields_to_send: List[Tuple[str, Any]], + debug: bool, + batch_outputs: bool = False, + ): + """Async implementation of send.""" + files = [] + outputs = [] + start_time = datetime.now() + + # Process each field + for name, value in fields_to_send: + encoded = self._encode_value(name, value, batch_outputs) + if encoded: + # Check if we got a list of encoded items (batched) or single item + if isinstance(encoded, list): + # Batched output - expand with _N suffixes + for i, (filename, data, mime_type, output_info) in enumerate(encoded): + batch_name = f"{name}_{i}" + files.append((batch_name, filename, data, mime_type)) + outputs.append(output_info.to_dict()) + else: + # Single item + filename, data, mime_type, output_info = encoded + files.append((name, filename, data, mime_type)) + outputs.append(output_info.to_dict()) + + # Build metadata + metadata = { + "request_id": context.request_id, + "prompt_id": context.prompt_id, + "timestamp": datetime.now().isoformat(), + "fields": outputs, + } + + # Send request + client = get_webhook_client() + + result = await client.send_multipart( + url=context.callback_url, + metadata=metadata, + files=files, + headers=context.get_auth_headers(), + timeout=context.timeout, + max_retries=context.max_retries, + compress=True, # Always use gzip compression + ) + + elapsed_ms = (datetime.now() - start_time).total_seconds() * 1000 + + if debug: + self._print_debug(context, files, outputs, result, elapsed_ms) + + if not result.success: + logger.error(f"WebhookSend failed: {result.error}") + else: + logger.info( + f"WebhookSend: Sent {len(files)} fields to {context.callback_url}" + ) + + def _encode_value( + self, + name: str, + value: Any, + batch_outputs: bool = False, + ) -> Optional[Union[Tuple[str, bytes, str, OutputInfo], List[Tuple[str, bytes, str, OutputInfo]]]]: + """ + Encode value to appropriate format for multipart upload. + + Returns: + tuple: (filename, data_bytes, mime_type, output_info) or None + list: List of tuples when batch_outputs=True and value is batched + """ + # IMAGE tensor + if torch.is_tensor(value) and len(value.shape) == 4: + # Batched images [B, H, W, C] + batch_size = value.shape[0] + + if batch_outputs and batch_size > 1: + # Return all images as separate items + results = [] + for i in range(batch_size): + img_bytes = self._tensor_to_png(value[i]) + filename = f"{name}_{i}.png" + output_info = OutputInfo( + type="IMAGE", + filename=filename, + mime_type="image/png", + file_size_bytes=len(img_bytes), + width=value.shape[2], + height=value.shape[1], + channels=value.shape[3] if len(value.shape) > 3 else 3, + dtype="float32", + format="png", + batch_index=i, + batch_size=batch_size, + ) + results.append((filename, img_bytes, "image/png", output_info)) + return results + else: + # Send only first image (original behavior) + data = self._tensor_to_png(value[0]) + filename = f"{name}.png" + + output_info = OutputInfo( + type="IMAGE", + filename=filename, + mime_type="image/png", + file_size_bytes=len(data), + width=value.shape[2], + height=value.shape[1], + channels=value.shape[3] if len(value.shape) > 3 else 3, + dtype="float32", + format="png", + batch_index=0, + batch_size=batch_size, + ) + return (filename, data, "image/png", output_info) + + # MASK tensor [B, H, W] or [H, W] - check before IMAGE to avoid confusion + # Masks are 2D or 3D with small batch dimension (no color channel) + if torch.is_tensor(value) and len(value.shape) in (2, 3): + # Check if this looks like a mask: + # - 2D tensor [H, W] is definitely a mask + # - 3D tensor [B, H, W] where B < 10 is a batched mask + # - 3D tensor [H, W, C] where C is 3 or 4 is an image + is_mask = False + is_batched_mask = False + batch_size = 1 + + if len(value.shape) == 2: + is_mask = True + elif len(value.shape) == 3: + # [B, H, W] mask vs [H, W, C] image + # If last dim is 1, 3, or 4, it's likely an image + # If first dim is small and last dim is large, it's likely a mask batch + if value.shape[-1] not in (1, 3, 4) and value.shape[0] < 10: + is_mask = True + is_batched_mask = value.shape[0] > 1 + batch_size = value.shape[0] + elif value.shape[0] == 1 and value.shape[-1] > 10: + # [1, H, W] is a batched mask + is_mask = True + is_batched_mask = False + batch_size = 1 + + if is_mask: + if batch_outputs and is_batched_mask and batch_size > 1: + # Return all masks as separate items + results = [] + for i in range(batch_size): + mask = value[i] + mask_bytes = self._mask_to_png(mask) + filename = f"{name}_{i}.png" + output_info = OutputInfo( + type="MASK", + filename=filename, + mime_type="image/png", + file_size_bytes=len(mask_bytes), + width=mask.shape[1], + height=mask.shape[0], + format="png", + batch_index=i, + batch_size=batch_size, + ) + results.append((filename, mask_bytes, "image/png", output_info)) + return results + else: + # Send only first mask (original behavior) + mask = value[0] if len(value.shape) == 3 else value + data = self._mask_to_png(mask) + filename = f"{name}.png" + + output_info = OutputInfo( + type="MASK", + filename=filename, + mime_type="image/png", + file_size_bytes=len(data), + width=mask.shape[1], + height=mask.shape[0], + format="png", + batch_index=0, + batch_size=batch_size, + ) + return (filename, data, "image/png", output_info) + + # IMAGE tensor (single) [H, W, C] + if torch.is_tensor(value) and len(value.shape) == 3: + data = self._tensor_to_png(value) + filename = f"{name}.png" + + output_info = OutputInfo( + type="IMAGE", + filename=filename, + mime_type="image/png", + file_size_bytes=len(data), + width=value.shape[1], + height=value.shape[0], + channels=value.shape[2] if len(value.shape) > 2 else 3, + dtype="float32", + format="png", + ) + return (filename, data, "image/png", output_info) + + # AUDIO dict + if isinstance(value, dict) and "waveform" in value: + data = self._audio_to_flac(value) + if data: + filename = f"{name}.flac" + output_info = OutputInfo( + type="AUDIO", + filename=filename, + mime_type="audio/flac", + file_size_bytes=len(data), + sample_rate=value.get("sample_rate", 44100), + format="flac", + ) + return (filename, data, "audio/flac", output_info) + + # VIDEO dict or tensor + if isinstance(value, dict) and "images" in value: + data = self._video_to_mp4(value) + if data: + filename = f"{name}.mp4" + fps = value.get("fps", 24) + images = value.get("images") + output_info = OutputInfo( + type="VIDEO", + filename=filename, + mime_type="video/mp4", + file_size_bytes=len(data), + width=images.shape[2] if torch.is_tensor(images) else None, + height=images.shape[1] if torch.is_tensor(images) else None, + format="mp4", + ) + return (filename, data, "video/mp4", output_info) + + # MESH dict + if isinstance(value, dict) and ("vertices" in value or "faces" in value): + data = self._mesh_to_glb(value) + if data: + filename = f"{name}.glb" + vertices = value.get("vertices") + faces = value.get("faces") + output_info = OutputInfo( + type="MESH", + filename=filename, + mime_type="model/gltf-binary", + file_size_bytes=len(data), + format="glb", + ) + return (filename, data, "model/gltf-binary", output_info) + + # LATENT dict + if isinstance(value, dict) and "samples" in value: + data = self._latent_to_safetensors(value) + if data: + filename = f"{name}.safetensors" + samples = value.get("samples") + output_info = OutputInfo( + type="LATENT", + filename=filename, + mime_type="application/octet-stream", + file_size_bytes=len(data), + format="safetensors", + ) + return (filename, data, "application/octet-stream", output_info) + + # STRING + if isinstance(value, str): + data = value.encode("utf-8") + filename = f"{name}.txt" + output_info = OutputInfo( + type="STRING", + filename=filename, + mime_type="text/plain", + file_size_bytes=len(data), + inline_content=value if len(value) < 1000 else None, + ) + return (filename, data, "text/plain", output_info) + + # INT, FLOAT, BOOLEAN + if isinstance(value, (int, float, bool)): + str_value = str(value).lower() if isinstance(value, bool) else str(value) + data = str_value.encode("utf-8") + filename = f"{name}.txt" + type_name = type(value).__name__.upper() + output_info = OutputInfo( + type=type_name, + filename=filename, + mime_type="text/plain", + file_size_bytes=len(data), + inline_content=str_value, + ) + return (filename, data, "text/plain", output_info) + + # BYTES + if isinstance(value, bytes): + filename = f"{name}.bin" + output_info = OutputInfo( + type="BYTES", + filename=filename, + mime_type="application/octet-stream", + file_size_bytes=len(value), + ) + return (filename, value, "application/octet-stream", output_info) + + # Try JSON serialization for other types + try: + json_str = json.dumps(value, default=str) + data = json_str.encode("utf-8") + filename = f"{name}.json" + output_info = OutputInfo( + type="JSON", + filename=filename, + mime_type="application/json", + file_size_bytes=len(data), + ) + return (filename, data, "application/json", output_info) + except Exception: + pass + + logger.warning(f"WebhookSend: Unable to encode field '{name}' of type {type(value)}") + return None + + def _tensor_to_png(self, tensor: torch.Tensor) -> bytes: + """Convert image tensor [H, W, C] to PNG bytes.""" + np_image = (tensor.cpu().numpy() * 255).clip(0, 255).astype(np.uint8) + pil_image = Image.fromarray(np_image) + + buffer = io.BytesIO() + pil_image.save(buffer, format="PNG", compress_level=4) + return buffer.getvalue() + + def _mask_to_png(self, tensor: torch.Tensor) -> bytes: + """Convert mask tensor [H, W] to grayscale PNG bytes.""" + np_mask = (tensor.cpu().numpy() * 255).clip(0, 255).astype(np.uint8) + pil_image = Image.fromarray(np_mask, mode='L') + + buffer = io.BytesIO() + pil_image.save(buffer, format="PNG") + return buffer.getvalue() + + def _audio_to_flac(self, audio: dict) -> Optional[bytes]: + """Convert audio dict to FLAC bytes.""" + try: + import av + except ImportError: + logger.warning("av library not available for audio encoding") + return None + + waveform = audio.get("waveform") + sample_rate = audio.get("sample_rate", 44100) + + if waveform is None: + return None + + if len(waveform.shape) == 3: + waveform = waveform[0] + + try: + buffer = io.BytesIO() + container = av.open(buffer, mode="w", format="flac") + + layout = "mono" if waveform.shape[0] == 1 else "stereo" + stream = container.add_stream("flac", rate=sample_rate, layout=layout) + + audio_np = waveform.cpu().numpy() + + frame = av.AudioFrame.from_ndarray( + audio_np.reshape(1, -1).astype(np.float32), + format="flt", + layout=layout, + ) + frame.sample_rate = sample_rate + + for packet in stream.encode(frame): + container.mux(packet) + for packet in stream.encode(None): + container.mux(packet) + + container.close() + buffer.seek(0) + return buffer.getvalue() + + except Exception as e: + logger.error(f"Failed to encode audio: {e}") + return None + + def _video_to_mp4(self, video: dict) -> Optional[bytes]: + """Convert video dict to MP4 bytes.""" + try: + import av + except ImportError: + logger.warning("av library not available for video encoding") + return None + + images = video.get("images") + fps = video.get("fps", 24) + + if images is None: + return None + + try: + buffer = io.BytesIO() + container = av.open(buffer, mode="w", format="mp4") + stream = container.add_stream("libx264", rate=fps) + + if len(images.shape) == 4: + height, width = images.shape[1], images.shape[2] + else: + height, width = images.shape[0], images.shape[1] + + stream.width = width + stream.height = height + stream.pix_fmt = "yuv420p" + + if len(images.shape) == 4: + for i in range(images.shape[0]): + np_frame = (images[i].cpu().numpy() * 255).clip(0, 255).astype(np.uint8) + frame = av.VideoFrame.from_ndarray(np_frame, format="rgb24") + for packet in stream.encode(frame): + container.mux(packet) + + for packet in stream.encode(None): + container.mux(packet) + + container.close() + buffer.seek(0) + return buffer.getvalue() + + except Exception as e: + logger.error(f"Failed to encode video: {e}") + return None + + def _mesh_to_glb(self, mesh: dict) -> Optional[bytes]: + """Convert mesh dict to GLB bytes.""" + try: + vertices = mesh.get("vertices") + faces = mesh.get("faces") + + if vertices is None or faces is None: + return None + + if torch.is_tensor(vertices): + vertices = vertices.cpu().numpy() + if torch.is_tensor(faces): + faces = faces.cpu().numpy() + + # Handle batch dimension + if len(vertices.shape) == 3: + vertices = vertices[0] + if len(faces.shape) == 3: + faces = faces[0] + + vertices = vertices.astype(np.float32) + faces = faces.astype(np.uint32) + + # Calculate bounding box + v_min = vertices.min(axis=0).tolist() + v_max = vertices.max(axis=0).tolist() + + # Create buffer data + vertex_data = vertices.tobytes() + index_data = faces.flatten().tobytes() + + def pad4(data): + remainder = len(data) % 4 + if remainder: + data += b'\x00' * (4 - remainder) + return data + + vertex_data = pad4(vertex_data) + index_data = pad4(index_data) + buffer_data = vertex_data + index_data + + # Create glTF JSON + gltf = { + "asset": {"version": "2.0", "generator": "ComfyUI-Webhook"}, + "scene": 0, + "scenes": [{"nodes": [0]}], + "nodes": [{"mesh": 0}], + "meshes": [{ + "primitives": [{ + "attributes": {"POSITION": 0}, + "indices": 1 + }] + }], + "accessors": [ + { + "bufferView": 0, + "componentType": 5126, + "count": len(vertices), + "type": "VEC3", + "min": v_min, + "max": v_max + }, + { + "bufferView": 1, + "componentType": 5125, + "count": faces.size, + "type": "SCALAR" + } + ], + "bufferViews": [ + { + "buffer": 0, + "byteOffset": 0, + "byteLength": len(vertex_data) + }, + { + "buffer": 0, + "byteOffset": len(vertex_data), + "byteLength": len(index_data) + } + ], + "buffers": [{"byteLength": len(buffer_data)}] + } + + json_data = json.dumps(gltf, separators=(',', ':')).encode('utf-8') + json_data = pad4(json_data) + + # Build GLB + glb = io.BytesIO() + glb.write(struct.pack('<4sII', b'glTF', 2, 12 + 8 + len(json_data) + 8 + len(buffer_data))) + glb.write(struct.pack(' Optional[bytes]: + try: + from safetensors.torch import save + samples = latent.get("samples") + if samples is None: + return None + return save({"samples": samples}) + except Exception as e: + logger.error(f"Failed to encode latent: {e}") + return None + + def _print_debug( + self, + context: WebhookContext, + files: List[Tuple[str, str, bytes, str]], + outputs: List[Dict], + result: WebhookResult, + elapsed_ms: float + ): + """Print debug information about the outgoing request.""" + lines = [ + "", + "[Webhook Send] Outgoing Request", + "=" * 50, + f" Target URL: {context.callback_url}", + f" Method: POST", + f" Content-Type: multipart/form-data", + f" Auth Header: {context.censor_auth()}", + f" Request ID: {context.request_id}", + "", + f" Fields ({len(files)}):", + ] + + for i, (name, filename, data, mime_type) in enumerate(files): + prefix = " +-" if i == len(files) - 1 else " |-" + + # Find output info for additional details + output = outputs[i] if i < len(outputs) else {} + type_name = output.get("type", "UNKNOWN") + + if type_name == "IMAGE": + w = output.get("width", "?") + h = output.get("height", "?") + lines.append(f"{prefix} {name:20} ({type_name}) {w}x{h}, PNG, {format_size(len(data))}") + elif type_name == "MASK": + w = output.get("width", "?") + h = output.get("height", "?") + lines.append(f"{prefix} {name:20} ({type_name}) {w}x{h}, PNG, {format_size(len(data))}") + elif type_name == "STRING": + content = output.get("inline_content") + if content and len(content) < 30: + lines.append(f"{prefix} {name:20} ({type_name}) \"{content}\"") + else: + lines.append(f"{prefix} {name:20} ({type_name}) {format_size(len(data))}") + else: + lines.append(f"{prefix} {name:20} ({type_name}) {format_size(len(data))}") + + lines.append("") + lines.append(" Response:") + if result.success: + lines.append(f" Status: {result.status} OK") + else: + lines.append(f" Status: {result.status or 'N/A'} {result.error or 'Failed'}") + + lines.append(f" Time: {elapsed_ms:.0f} ms") + + if result.response_body: + body = result.response_body + if len(body) > 100: + body = body[:97] + "..." + lines.append(f" Body: {body}") + + if result.retries > 0: + lines.append(f" Retries: {result.retries}") + + lines.append("=" * 50) + print("\n".join(lines)) + + def _print_error(self, context: WebhookContext, error: str): + """Print error information.""" + lines = [ + "", + "[Webhook Send] Request Failed", + "=" * 50, + f" Target URL: {context.callback_url}", + f" Request ID: {context.request_id}", + "", + f" Error: {error}", + "=" * 50, + ] + print("\n".join(lines)) diff --git a/nodes/transformer.py b/nodes/transformer.py new file mode 100644 index 0000000..aa77008 --- /dev/null +++ b/nodes/transformer.py @@ -0,0 +1,581 @@ +"""WebhookTransformer node - Extract a single atomic field from webhook context.""" + +import io +import logging +from typing import Any, Dict, List, Optional, Tuple + +import numpy as np +import torch +from PIL import Image + +from ..core.types import WebhookContext, WebhookField +from ..processors.inputs import WebhookInputProcessor +from ..utils.helpers import format_size, run_async + +logger = logging.getLogger(__name__) + +_processor = None + + +def get_processor() -> WebhookInputProcessor: + global _processor + if _processor is None: + _processor = WebhookInputProcessor() + return _processor + + +class WebhookTransformer: + """ + Extract a single atomic field from the webhook request. + + Field names are atomic (flat) - no JSON paths, no nesting. + Outputs wildcard type (*) that connects to any ComfyUI input. + + Type Inference: + - Text fields with numbers -> INT or FLOAT + - Text fields -> STRING + - File uploads -> IMAGE, AUDIO, VIDEO, MESH, LATENT based on content type + - Boolean strings ("true"/"false") -> BOOLEAN + + Missing Field Handling: + - If field missing AND default_value provided -> use default + - If field missing AND NO default -> STOP workflow with error + """ + + @classmethod + def INPUT_TYPES(cls): + return { + "required": { + "webhook_context": ("WEBHOOK_CONTEXT",), + "field": ("STRING", { + "default": "prompt", + "tooltip": "Field name to extract (atomic, no nesting)" + }), + }, + "optional": { + "default_value": ("*", { + "tooltip": "Fallback value if field not found (leave empty to require field)" + }), + "debug": ("BOOLEAN", { + "default": False, + "tooltip": "Enable debug logging" + }), + }, + } + + RETURN_TYPES = ("*",) + RETURN_NAMES = ("value",) + FUNCTION = "transform" + CATEGORY = "webhook" + DESCRIPTION = "Extract a single atomic field from webhook request. Outputs wildcard type that connects to any input." + + @classmethod + def VALIDATE_INPUTS(cls, webhook_context=None, field="", default_value=None, debug=False): + """Validate inputs before execution.""" + # Basic validation - actual field checking happens in transform() + if not field or not field.strip(): + return "Field name cannot be empty" + return True + + def transform( + self, + webhook_context, + field: str, + default_value=None, + debug=False, + ): + """ + Extract field from webhook context. + + Raises: + ValueError: If field is missing and no default provided + """ + # Validate context (use duck typing for flexibility with module loading) + if not hasattr(webhook_context, 'get_field_value') or not hasattr(webhook_context, 'has_field'): + if default_value is not None: + if debug: + self._print_debug_default(field, default_value, "Invalid webhook context") + return (default_value,) + raise ValueError( + f"[Webhook Transformer] ERROR: Invalid webhook context for field '{field}'" + ) + + # Check if field exists + has_field = webhook_context.has_field(field) + + if not has_field: + # Field not found + if default_value is not None: + if debug: + self._print_debug_default(field, default_value, "Field not found") + return (default_value,) + + # No default - STOP workflow + available_fields = webhook_context.get_field_names() + self._print_error(field, available_fields) + raise ValueError( + f"[Webhook Transformer] Required field '{field}' not found. " + f"Available fields: {', '.join(available_fields) if available_fields else '(none)'}. " + f"Provide field or set default_value." + ) + + # Get field value + webhook_field = webhook_context.get_field(field) + raw_value = webhook_context.get_field_value(field) + + # Process and convert value based on type inference + processed_value, value_type, debug_info = self._process_value( + raw_value, webhook_field + ) + + if debug: + self._print_debug_found(field, processed_value, value_type, debug_info) + + return (processed_value,) + + def _process_value( + self, + raw_value: Any, + webhook_field: Optional[WebhookField] + ) -> Tuple[Any, str, Dict]: + """ + Process raw value and infer type. + + Returns: + tuple: (processed_value, type_name, debug_info_dict) + """ + debug_info = {} + + # Handle file uploads + if webhook_field and webhook_field.is_file: + return self._process_file(raw_value, webhook_field) + + # Handle string values + if isinstance(raw_value, str): + # Try to infer type from string content + + # Boolean + if raw_value.lower() in ("true", "false", "yes", "no", "1", "0"): + bool_value = raw_value.lower() in ("true", "yes", "1") + debug_info["original"] = raw_value + return (bool_value, "BOOLEAN", debug_info) + + # Integer + try: + if raw_value.isdigit() or (raw_value.startswith("-") and raw_value[1:].isdigit()): + int_value = int(raw_value) + debug_info["original"] = raw_value + return (int_value, "INT", debug_info) + except (ValueError, AttributeError): + pass + + # Float + try: + if "." in raw_value or "e" in raw_value.lower(): + float_value = float(raw_value) + debug_info["original"] = raw_value + return (float_value, "FLOAT", debug_info) + except (ValueError, AttributeError): + pass + + # Check if it's base64 encoded data + if raw_value.startswith("data:"): + return self._process_data_uri(raw_value) + + # Plain string + debug_info["length"] = len(raw_value) + return (raw_value, "STRING", debug_info) + + # Handle numeric types directly + if isinstance(raw_value, bool): + return (raw_value, "BOOLEAN", debug_info) + if isinstance(raw_value, int): + return (raw_value, "INT", debug_info) + if isinstance(raw_value, float): + return (raw_value, "FLOAT", debug_info) + + # Handle bytes (file data) + if isinstance(raw_value, bytes): + return self._process_bytes(raw_value) + + # Handle torch tensors + if torch.is_tensor(raw_value): + debug_info["shape"] = list(raw_value.shape) + debug_info["dtype"] = str(raw_value.dtype) + return (raw_value, "TENSOR", debug_info) + + # Handle dicts (could be LATENT, AUDIO, etc.) + if isinstance(raw_value, dict): + # Check for known dict types + if "samples" in raw_value: + return (raw_value, "LATENT", {"type": "latent_dict"}) + if "waveform" in raw_value: + return (raw_value, "AUDIO", {"type": "audio_dict"}) + + # Generic dict - return as is + debug_info["keys"] = list(raw_value.keys()) + return (raw_value, "DICT", debug_info) + + # Handle lists + if isinstance(raw_value, list): + debug_info["length"] = len(raw_value) + return (raw_value, "LIST", debug_info) + + # Default: return as-is + debug_info["python_type"] = type(raw_value).__name__ + return (raw_value, "ANY", debug_info) + + def _process_file( + self, + raw_value: Any, + webhook_field: WebhookField + ) -> Tuple[Any, str, Dict]: + """Process file upload based on content type.""" + content_type = webhook_field.content_type or "" + debug_info = { + "filename": webhook_field.filename, + "content_type": content_type, + "size_bytes": webhook_field.size_bytes, + } + + data = raw_value if isinstance(raw_value, bytes) else None + + if data is None: + return (raw_value, "UNKNOWN", debug_info) + + # Image types + if content_type.startswith("image/"): + try: + tensor, info = self._decode_image(data) + debug_info.update(info) + return (tensor, "IMAGE", debug_info) + except Exception as e: + logger.warning(f"Failed to decode image: {e}") + return (data, "BYTES", debug_info) + + # Audio types + if content_type.startswith("audio/"): + try: + audio_dict, info = self._decode_audio(data) + debug_info.update(info) + return (audio_dict, "AUDIO", debug_info) + except Exception as e: + logger.warning(f"Failed to decode audio: {e}") + return (data, "BYTES", debug_info) + + # Video types + if content_type.startswith("video/"): + try: + video, info = self._decode_video(data) + debug_info.update(info) + return (video, "VIDEO", debug_info) + except Exception as e: + logger.warning(f"Failed to decode video: {e}") + return (data, "BYTES", debug_info) + + # 3D mesh types + if content_type in ("model/gltf-binary", "model/obj", "model/stl", "application/octet-stream"): + # Try to detect from filename + filename = webhook_field.filename or "" + if filename.endswith((".glb", ".gltf", ".obj", ".stl")): + try: + mesh, info = self._decode_mesh(data, filename) + debug_info.update(info) + return (mesh, "MESH", debug_info) + except Exception as e: + logger.warning(f"Failed to decode mesh: {e}") + return (data, "BYTES", debug_info) + + # Safetensors (latent) + if webhook_field.filename and webhook_field.filename.endswith(".safetensors"): + try: + latent, info = self._decode_latent(data) + debug_info.update(info) + return (latent, "LATENT", debug_info) + except Exception as e: + logger.warning(f"Failed to decode latent: {e}") + return (data, "BYTES", debug_info) + + # Default: return raw bytes + return (data, "BYTES", debug_info) + + def _process_data_uri(self, data_uri: str) -> Tuple[Any, str, Dict]: + """Process data URI (base64 encoded data).""" + processor = get_processor() + debug_info = {} + + try: + # Detect type from data URI + if data_uri.startswith("data:image/"): + tensor = run_async(processor.process_image(data_uri)) + debug_info["source"] = "base64" + debug_info["dimensions"] = f"{tensor.shape[2]}x{tensor.shape[1]}" + return (tensor, "IMAGE", debug_info) + + elif data_uri.startswith("data:audio/"): + audio = run_async(processor.process_audio(data_uri)) + debug_info["source"] = "base64" + return (audio, "AUDIO", debug_info) + + elif data_uri.startswith("data:video/"): + video = run_async(processor.process_video(data_uri)) + debug_info["source"] = "base64" + return (video, "VIDEO", debug_info) + + except Exception as e: + logger.warning(f"Failed to process data URI: {e}") + + # Return as string if can't process + debug_info["length"] = len(data_uri) + return (data_uri, "STRING", debug_info) + + def _process_bytes(self, data: bytes) -> Tuple[Any, str, Dict]: + """Process raw bytes by detecting format.""" + debug_info = {"size_bytes": len(data)} + + # Try to detect image from magic bytes + if data[:8] == b'\x89PNG\r\n\x1a\n' or data[:2] == b'\xff\xd8': + try: + tensor, info = self._decode_image(data) + debug_info.update(info) + return (tensor, "IMAGE", debug_info) + except Exception: + pass + + # Try to detect audio + if data[:4] == b'fLaC' or data[:4] == b'RIFF': + try: + audio, info = self._decode_audio(data) + debug_info.update(info) + return (audio, "AUDIO", debug_info) + except Exception: + pass + + # Default: return raw bytes + return (data, "BYTES", debug_info) + + def _decode_image(self, data: bytes) -> Tuple[torch.Tensor, Dict]: + """Decode image bytes to tensor.""" + img = Image.open(io.BytesIO(data)) + img = img.convert("RGB") + + np_image = np.array(img).astype(np.float32) / 255.0 + tensor = torch.from_numpy(np_image).unsqueeze(0) # [1, H, W, C] + + info = { + "dimensions": f"{img.width}x{img.height}", + "channels": 3, + "dtype": "float32", + } + return tensor, info + + def _decode_audio(self, data: bytes) -> Tuple[Dict, Dict]: + """Decode audio bytes to audio dict.""" + try: + import av + except ImportError: + raise ImportError("av library required for audio decoding") + + buffer = io.BytesIO(data) + container = av.open(buffer) + + audio_stream = container.streams.audio[0] + sample_rate = audio_stream.rate + + frames = [] + for frame in container.decode(audio=0): + frames.append(frame.to_ndarray()) + + container.close() + + audio_np = np.concatenate(frames, axis=1) + waveform = torch.from_numpy(audio_np).unsqueeze(0) + + info = { + "sample_rate": sample_rate, + "channels": audio_np.shape[0], + "duration_seconds": audio_np.shape[1] / sample_rate, + } + + return {"waveform": waveform, "sample_rate": sample_rate}, info + + def _decode_video(self, data: bytes) -> Tuple[Dict, Dict]: + """Decode video bytes to video dict.""" + try: + import av + except ImportError: + raise ImportError("av library required for video decoding") + + buffer = io.BytesIO(data) + container = av.open(buffer) + + video_stream = container.streams.video[0] + fps = float(video_stream.average_rate) + + frames = [] + for frame in container.decode(video=0): + np_frame = frame.to_ndarray(format="rgb24") + frames.append(np_frame) + + container.close() + + if not frames: + raise ValueError("No video frames found") + + frames_np = np.stack(frames) + frames_tensor = torch.from_numpy(frames_np).float() / 255.0 + + info = { + "fps": fps, + "frame_count": len(frames), + "dimensions": f"{frames_np.shape[2]}x{frames_np.shape[1]}", + } + + return {"images": frames_tensor, "fps": fps}, info + + def _decode_mesh(self, data: bytes, filename: str) -> Tuple[Dict, Dict]: + """Decode mesh bytes.""" + processor = get_processor() + + # Use processor's mesh parsing + if filename.endswith(".glb") or filename.endswith(".gltf"): + mesh = processor._parse_glb(data) + elif filename.endswith(".obj"): + mesh = processor._parse_obj(data.decode("utf-8")) + elif filename.endswith(".stl"): + mesh = processor._parse_stl_binary(data) + else: + raise ValueError(f"Unsupported mesh format: {filename}") + + vertices = mesh.get("vertices") + faces = mesh.get("faces") + + info = { + "vertex_count": vertices.shape[1] if vertices is not None else 0, + "face_count": faces.shape[1] if faces is not None else 0, + } + + return mesh, info + + def _decode_latent(self, data: bytes) -> Tuple[Dict, Dict]: + """Decode latent from safetensors.""" + from safetensors.torch import load + + buffer = io.BytesIO(data) + tensors = load(buffer.read()) + + samples = tensors.get("samples") + if samples is None: + raise ValueError("No 'samples' key in safetensors") + + info = { + "shape": list(samples.shape), + "dtype": str(samples.dtype), + } + + return {"samples": samples}, info + + def _print_debug_found( + self, + field: str, + value: Any, + value_type: str, + debug_info: dict + ): + """Print debug info for found field.""" + lines = [ + "", + f"[Webhook Transformer] Field: \"{field}\"", + "=" * 50, + f" Status: Found", + f" Type: {value_type}", + ] + + # Add type-specific info + if value_type == "STRING": + preview = str(value) + if len(preview) > 50: + preview = preview[:47] + "..." + lines.append(f" Value: \"{preview}\"") + lines.append(f" Length: {debug_info.get('length', len(str(value)))} characters") + + elif value_type == "IMAGE": + lines.append(f" Dimensions: {debug_info.get('dimensions', 'unknown')}") + lines.append(f" Channels: {debug_info.get('channels', 'unknown')}") + lines.append(f" Dtype: {debug_info.get('dtype', 'unknown')}") + if debug_info.get('size_bytes'): + lines.append(f" Size: {format_size(debug_info['size_bytes'])}") + lines.append(f" Source: {debug_info.get('source', 'file upload')}") + + elif value_type == "AUDIO": + lines.append(f" Sample Rate: {debug_info.get('sample_rate', 'unknown')} Hz") + lines.append(f" Channels: {debug_info.get('channels', 'unknown')}") + if debug_info.get('duration_seconds'): + lines.append(f" Duration: {debug_info['duration_seconds']:.2f}s") + + elif value_type in ("INT", "FLOAT", "BOOLEAN"): + lines.append(f" Value: {value}") + if debug_info.get('original'): + lines.append(f" Original: \"{debug_info['original']}\"") + + elif value_type == "LATENT": + if debug_info.get('shape'): + lines.append(f" Shape: {debug_info['shape']}") + + elif value_type == "MESH": + lines.append(f" Vertices: {debug_info.get('vertex_count', 'unknown')}") + lines.append(f" Faces: {debug_info.get('face_count', 'unknown')}") + + else: + # Generic info + preview = str(value) + if len(preview) > 50: + preview = preview[:47] + "..." + lines.append(f" Value: {preview}") + + lines.append("=" * 50) + print("\n".join(lines)) + + def _print_debug_default(self, field: str, default_value: Any, reason: str): + """Print debug info when using default value.""" + lines = [ + "", + f"[Webhook Transformer] Field: \"{field}\"", + "=" * 50, + f" Status: Not Found -> Using Default", + f" Reason: {reason}", + f" Type: {type(default_value).__name__}", + ] + + preview = str(default_value) + if len(preview) > 50: + preview = preview[:47] + "..." + lines.append(f" Value: {preview}") + + lines.append("=" * 50) + print("\n".join(lines)) + + def _print_error(self, field: str, available_fields: List[str]): + """Print error when field is missing and no default.""" + lines = [ + "", + "[Webhook Transformer] ERROR", + "=" * 50, + f" Field: \"{field}\"", + f" Status: NOT FOUND", + "", + " Available fields:", + ] + + if available_fields: + for i, name in enumerate(available_fields): + prefix = " +-" if i == len(available_fields) - 1 else " |-" + lines.append(f"{prefix} {name}") + else: + lines.append(" (none)") + + lines.append("") + lines.append(" -> Workflow stopped. Provide field or set default_value.") + lines.append("=" * 50) + + print("\n".join(lines)) diff --git a/processors/__init__.py b/processors/__init__.py new file mode 100644 index 0000000..48668ee --- /dev/null +++ b/processors/__init__.py @@ -0,0 +1 @@ +"""Processors for input and output handling.""" diff --git a/processors/inputs.py b/processors/inputs.py new file mode 100644 index 0000000..8fd8a71 --- /dev/null +++ b/processors/inputs.py @@ -0,0 +1,746 @@ +"""Input processing for webhook data.""" + +import asyncio +import base64 +import io +import json +import logging +import re +from typing import Any, List, Optional, Union + +import numpy as np +import torch +from PIL import Image, ImageOps + +try: + import aiohttp +except ImportError: + aiohttp = None + +try: + import torchaudio +except ImportError: + torchaudio = None + +logger = logging.getLogger(__name__) + +DATA_URL_PATTERN = re.compile(r'^data:([^;,]+)?(;base64)?,(.*)$', re.DOTALL) +HTTP_URL_PATTERN = re.compile(r'^https?://', re.IGNORECASE) + + +class WebhookInputProcessor: + """Processes webhook input data into ComfyUI-compatible formats.""" + + def __init__(self, download_timeout: float = 30.0): + self.download_timeout = download_timeout + + async def process_inputs(self, webhook_inputs: dict) -> dict: + """ + Process all inputs and return ComfyUI-compatible values. + + Args: + webhook_inputs: Dictionary of input name -> value + + Returns: + Dictionary of input name -> processed value + """ + processed = {} + + for key, value in webhook_inputs.items(): + try: + processed[key] = await self._process_value(value) + except Exception as e: + logger.error(f"Failed to process input '{key}': {e}") + # Keep original value on error + processed[key] = value + + return processed + + async def _process_value(self, value: Any) -> Any: + """Process a single value based on its type.""" + if isinstance(value, str): + return await self._process_string(value) + elif isinstance(value, list): + return await self._process_array(value) + elif isinstance(value, dict): + # JSON data - serialize to string + return json.dumps(value) + else: + # Numbers, booleans - pass through + return value + + async def _process_string(self, value: str) -> Any: + """Process a string value, detecting if it's base64/URL data.""" + if self._is_base64_image(value): + return await self._decode_base64_image(value) + elif self._is_base64_audio(value): + return await self._decode_base64_audio(value) + elif self._is_url(value): + return await self._download_and_decode(value) + else: + # Plain string + return value + + async def _process_array(self, items: list) -> Union[torch.Tensor, list]: + """ + Process array of items. + + If all items are images, returns a batched tensor [N, H, W, C]. + Otherwise returns a list of processed items. + """ + if not items: + return [] + + # Check if all items are image data + if all(self._is_image_data(item) for item in items): + tensors = [] + for item in items: + if isinstance(item, str): + if self._is_base64_image(item): + tensor = await self._decode_base64_image(item) + elif self._is_url(item): + tensor = await self._download_and_decode(item) + else: + continue + tensors.append(tensor) + + if tensors: + # Stack into batch tensor [N, H, W, C] + return self._batch_images(tensors) + return [] + + # Otherwise process each item individually + return [await self._process_value(item) for item in items] + + def _batch_images(self, tensors: List[torch.Tensor]) -> torch.Tensor: + """ + Batch multiple image tensors, handling different sizes. + + Args: + tensors: List of [1, H, W, C] tensors + + Returns: + Batched tensor [N, H, W, C] + """ + if not tensors: + return torch.zeros(0, 64, 64, 3) + + # Check if all images have the same size + shapes = [t.shape[1:3] for t in tensors] + if all(s == shapes[0] for s in shapes): + # All same size, simple cat + return torch.cat(tensors, dim=0) + + # Different sizes - pad to largest + max_h = max(t.shape[1] for t in tensors) + max_w = max(t.shape[2] for t in tensors) + + padded = [] + for t in tensors: + h, w = t.shape[1], t.shape[2] + if h < max_h or w < max_w: + # Center pad + pad_h_before = (max_h - h) // 2 + pad_h_after = max_h - h - pad_h_before + pad_w_before = (max_w - w) // 2 + pad_w_after = max_w - w - pad_w_before + # F.pad expects (left, right, top, bottom) for 4D tensor + t = torch.nn.functional.pad( + t.permute(0, 3, 1, 2), # [B, C, H, W] + (pad_w_before, pad_w_after, pad_h_before, pad_h_after), + mode='constant', + value=0 + ).permute(0, 2, 3, 1) # Back to [B, H, W, C] + padded.append(t) + + return torch.cat(padded, dim=0) + + # Detection methods + + def _is_base64_image(self, value: str) -> bool: + """Check if string is a base64-encoded image.""" + if value.startswith("data:image/"): + return True + # Check for raw base64 that might be an image (heuristic) + if len(value) > 100 and re.match(r'^[A-Za-z0-9+/]+=*$', value): + # Try to detect PNG/JPEG magic bytes + try: + decoded = base64.b64decode(value[:32]) + # PNG magic: 89 50 4E 47 + if decoded.startswith(b'\x89PNG'): + return True + # JPEG magic: FF D8 FF + if decoded.startswith(b'\xff\xd8\xff'): + return True + # WebP magic: RIFF....WEBP + if decoded.startswith(b'RIFF') and b'WEBP' in decoded[:16]: + return True + except: + pass + return False + + def _is_base64_audio(self, value: str) -> bool: + """Check if string is a base64-encoded audio.""" + return value.startswith("data:audio/") + + def _is_url(self, value: str) -> bool: + """Check if string is an HTTP(S) URL.""" + return bool(HTTP_URL_PATTERN.match(value)) + + def _is_image_data(self, value: Any) -> bool: + """Check if value is image data (base64 or URL).""" + if not isinstance(value, str): + return False + return self._is_base64_image(value) or ( + self._is_url(value) and + any(ext in value.lower() for ext in ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp']) + ) + + # Decoding methods + + async def _decode_base64_image(self, data: str) -> torch.Tensor: + """ + Decode base64 image to tensor. + + Supports: + - data:image/png;base64,... + - data:image/jpeg;base64,... + - data:image/webp;base64,... + - Raw base64 (no prefix) + + Returns: + Tensor [1, H, W, C] with values 0-1 + """ + # Strip data URL prefix if present + if data.startswith("data:"): + match = DATA_URL_PATTERN.match(data) + if match: + data = match.group(3) + else: + _, data = data.split(",", 1) + + # Decode base64 + image_bytes = base64.b64decode(data) + + # Load with PIL + pil_image = Image.open(io.BytesIO(image_bytes)) + pil_image = ImageOps.exif_transpose(pil_image) + + # Convert to RGB if needed + if pil_image.mode == "I": + # 16-bit images + pil_image = pil_image.point(lambda i: i * (1 / 255)) + if pil_image.mode != "RGB": + pil_image = pil_image.convert("RGB") + + # Convert to tensor [1, H, W, C] with values 0-1 + np_image = np.array(pil_image).astype(np.float32) / 255.0 + tensor = torch.from_numpy(np_image).unsqueeze(0) + + return tensor + + async def _decode_base64_audio(self, data: str) -> dict: + """ + Decode base64 audio to ComfyUI audio format. + + Returns: + {"waveform": tensor [1, channels, samples], "sample_rate": int} + """ + if torchaudio is None: + raise ImportError("torchaudio is required for audio processing") + + # Strip data URL prefix if present + if data.startswith("data:"): + _, data = data.split(",", 1) + + audio_bytes = base64.b64decode(data) + + # Use torchaudio to load + buffer = io.BytesIO(audio_bytes) + waveform, sample_rate = torchaudio.load(buffer) + + # Resample to 44100 if needed (common ComfyUI sample rate) + target_rate = 44100 + if sample_rate != target_rate: + resampler = torchaudio.transforms.Resample(sample_rate, target_rate) + waveform = resampler(waveform) + sample_rate = target_rate + + return { + "waveform": waveform.unsqueeze(0), # [1, channels, samples] + "sample_rate": sample_rate + } + + async def _download_and_decode(self, url: str) -> Any: + """ + Download content from URL and decode based on content type. + + Returns: + Decoded content (tensor for images, dict for audio, etc.) + """ + if aiohttp is None: + raise ImportError("aiohttp is required for URL downloads") + + timeout = aiohttp.ClientTimeout(total=self.download_timeout) + + async with aiohttp.ClientSession(timeout=timeout) as session: + async with session.get(url) as response: + response.raise_for_status() + content_type = response.headers.get("Content-Type", "").lower() + data = await response.read() + + # Detect type from content-type header or URL + if "image" in content_type or self._looks_like_image_url(url): + return await self._decode_image_bytes(data) + elif "audio" in content_type or self._looks_like_audio_url(url): + return await self._decode_audio_bytes(data) + else: + # Return as string + return data.decode("utf-8", errors="replace") + + async def _decode_image_bytes(self, data: bytes) -> torch.Tensor: + """Decode image bytes to tensor.""" + pil_image = Image.open(io.BytesIO(data)) + pil_image = ImageOps.exif_transpose(pil_image) + + if pil_image.mode == "I": + pil_image = pil_image.point(lambda i: i * (1 / 255)) + if pil_image.mode != "RGB": + pil_image = pil_image.convert("RGB") + + np_image = np.array(pil_image).astype(np.float32) / 255.0 + tensor = torch.from_numpy(np_image).unsqueeze(0) + return tensor + + async def _decode_audio_bytes(self, data: bytes) -> dict: + """Decode audio bytes to ComfyUI format.""" + if torchaudio is None: + raise ImportError("torchaudio is required for audio processing") + + buffer = io.BytesIO(data) + waveform, sample_rate = torchaudio.load(buffer) + + target_rate = 44100 + if sample_rate != target_rate: + resampler = torchaudio.transforms.Resample(sample_rate, target_rate) + waveform = resampler(waveform) + sample_rate = target_rate + + return { + "waveform": waveform.unsqueeze(0), + "sample_rate": sample_rate + } + + def _looks_like_image_url(self, url: str) -> bool: + """Check if URL looks like an image based on extension.""" + lower = url.lower() + return any(ext in lower for ext in ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp']) + + def _looks_like_audio_url(self, url: str) -> bool: + """Check if URL looks like audio based on extension.""" + lower = url.lower() + return any(ext in lower for ext in ['.mp3', '.wav', '.flac', '.ogg', '.opus', '.m4a']) + + # Specialized extraction methods for nodes + + async def process_image(self, value: Any) -> torch.Tensor: + """ + Process a single image input. + + Args: + value: Base64 string, URL, or already a tensor + + Returns: + Tensor [1, H, W, C] + """ + if isinstance(value, torch.Tensor): + return value + if isinstance(value, str): + if self._is_base64_image(value): + return await self._decode_base64_image(value) + elif self._is_url(value): + return await self._download_and_decode(value) + # Return empty tensor for invalid input + return torch.zeros(1, 64, 64, 3) + + async def process_audio(self, value: Any) -> dict: + """ + Process a single audio input. + + Args: + value: Base64 string, URL, or already an audio dict + + Returns: + {"waveform": tensor, "sample_rate": int} + """ + if isinstance(value, dict) and "waveform" in value: + return value + if isinstance(value, str): + if self._is_base64_audio(value): + return await self._decode_base64_audio(value) + elif self._is_url(value): + return await self._download_and_decode(value) + # Return empty audio for invalid input + return {"waveform": torch.zeros(1, 1, 44100), "sample_rate": 44100} + + async def process_mask(self, value: Any) -> torch.Tensor: + """ + Process a mask input (grayscale image). + + Args: + value: Base64 string or URL of grayscale image + + Returns: + Tensor [1, H, W] for MASK type + """ + if isinstance(value, torch.Tensor): + if len(value.shape) == 3: + return value + elif len(value.shape) == 4: + # Convert [B, H, W, C] to [B, H, W] using first channel + return value[:, :, :, 0] + + if isinstance(value, str): + # Decode image + if self._is_base64_image(value): + tensor = await self._decode_base64_image(value) + elif self._is_url(value): + tensor = await self._download_and_decode(value) + else: + return torch.zeros(1, 64, 64) + + # Convert to grayscale mask + if len(tensor.shape) == 4: + # Average RGB channels + mask = tensor.mean(dim=-1) + else: + mask = tensor + return mask + + return torch.zeros(1, 64, 64) + + async def process_video(self, value: Any) -> Any: + """ + Process video input. + + Note: Video processing is more complex and may require + additional dependencies like decord or av. + + Args: + value: Base64 string or URL + + Returns: + Video data (format depends on ComfyUI video nodes) + """ + # Basic implementation - return None for now + # Full video support would require decord or av + logger.warning("Video input processing not fully implemented") + return None + + async def process_latent(self, value: Any) -> dict: + """ + Process latent input (safetensors or torch file). + + Args: + value: Base64 string (safetensors/pt) or URL + + Returns: + {"samples": tensor, ...} latent dict + """ + if isinstance(value, dict) and "samples" in value: + return value + + default_latent = {"samples": torch.zeros(1, 4, 64, 64)} + + if isinstance(value, str): + try: + # Get data bytes + if value.startswith("data:"): + _, data_str = value.split(",", 1) + data = base64.b64decode(data_str) + elif self._is_url(value): + if aiohttp is None: + return default_latent + timeout = aiohttp.ClientTimeout(total=self.download_timeout) + async with aiohttp.ClientSession(timeout=timeout) as session: + async with session.get(value) as response: + response.raise_for_status() + data = await response.read() + else: + # Raw base64 + data = base64.b64decode(value) + + # Try safetensors first + try: + from safetensors.torch import load + buffer = io.BytesIO(data) + tensors = load(buffer.getvalue()) + if "samples" in tensors: + return {"samples": tensors["samples"]} + # Return first tensor as samples + for key, tensor in tensors.items(): + return {"samples": tensor} + except ImportError: + pass + except Exception: + pass + + # Try torch load + try: + buffer = io.BytesIO(data) + loaded = torch.load(buffer, weights_only=True) + if isinstance(loaded, dict) and "samples" in loaded: + return loaded + if isinstance(loaded, torch.Tensor): + return {"samples": loaded} + except Exception: + pass + + except Exception as e: + logger.error(f"Failed to process latent: {e}") + + return default_latent + + async def process_mesh(self, value: Any) -> dict: + """ + Process 3D mesh input (GLB, OBJ, STL). + + Args: + value: Base64 string or URL + + Returns: + {"vertices": tensor, "faces": tensor} mesh dict + """ + default_mesh = { + "vertices": torch.zeros(1, 3, 3), + "faces": torch.zeros(1, 1, 3, dtype=torch.long) + } + + if isinstance(value, dict) and "vertices" in value: + return value + + if isinstance(value, str): + try: + # Get data bytes + if value.startswith("data:"): + _, data_str = value.split(",", 1) + data = base64.b64decode(data_str) + elif self._is_url(value): + if aiohttp is None: + return default_mesh + timeout = aiohttp.ClientTimeout(total=self.download_timeout) + async with aiohttp.ClientSession(timeout=timeout) as session: + async with session.get(value) as response: + response.raise_for_status() + data = await response.read() + else: + # Raw base64 + data = base64.b64decode(value) + + # Detect format and parse + return self._parse_mesh_bytes(data, value) + + except Exception as e: + logger.error(f"Failed to process mesh: {e}") + + return default_mesh + + def _parse_mesh_bytes(self, data: bytes, hint: str = "") -> dict: + """Parse mesh from bytes based on format detection.""" + default_mesh = { + "vertices": torch.zeros(1, 3, 3), + "faces": torch.zeros(1, 1, 3, dtype=torch.long) + } + + # Detect format + if data.startswith(b'glTF'): + return self._parse_glb(data) + elif data.startswith(b'solid ') or data[:80].count(b'\x00') < 10: + # Text STL or ASCII format + if b'v ' in data[:1000]: + return self._parse_obj(data) + elif len(data) > 84: + # Binary STL check + try: + import struct + num_triangles = struct.unpack(' dict: + """Parse GLB (binary glTF) file.""" + import struct + import json as json_mod + + default_mesh = { + "vertices": torch.zeros(1, 3, 3), + "faces": torch.zeros(1, 1, 3, dtype=torch.long) + } + + try: + # GLB header: magic (4), version (4), length (4) + if len(data) < 12: + return default_mesh + + magic, version, length = struct.unpack('<4sII', data[:12]) + if magic != b'glTF': + return default_mesh + + # Read JSON chunk + chunk_length, chunk_type = struct.unpack(' len(data): + return default_mesh + + bin_length, bin_type = struct.unpack(' dict: + """Parse OBJ file.""" + default_mesh = { + "vertices": torch.zeros(1, 3, 3), + "faces": torch.zeros(1, 1, 3, dtype=torch.long) + } + + try: + text = data.decode('utf-8', errors='replace') + vertices = [] + faces = [] + + for line in text.split('\n'): + line = line.strip() + if line.startswith('v '): + parts = line.split()[1:4] + vertices.append([float(p) for p in parts]) + elif line.startswith('f '): + parts = line.split()[1:] + # Handle v/vt/vn format + face_indices = [] + for p in parts[:3]: # Only first 3 vertices for triangles + idx = int(p.split('/')[0]) - 1 # OBJ is 1-indexed + face_indices.append(idx) + if len(face_indices) == 3: + faces.append(face_indices) + + if vertices and faces: + return { + "vertices": torch.tensor(vertices).unsqueeze(0).float(), + "faces": torch.tensor(faces, dtype=torch.long).unsqueeze(0) + } + + except Exception as e: + logger.error(f"Failed to parse OBJ: {e}") + + return default_mesh + + def _parse_stl_binary(self, data: bytes) -> dict: + """Parse binary STL file.""" + import struct + + default_mesh = { + "vertices": torch.zeros(1, 3, 3), + "faces": torch.zeros(1, 1, 3, dtype=torch.long) + } + + try: + num_triangles = struct.unpack(' str: + """ + Resolve the full path to an output file. + + Args: + filename: Name of the file + subfolder: Subfolder within the directory + folder_type: Type of folder (output, temp, input) + + Returns: + Full filesystem path to the file + """ + if folder_paths is None: + # Fallback if folder_paths not available + base_dir = os.getcwd() + return os.path.join(base_dir, folder_type, subfolder, filename) + + if folder_type == "output": + base_dir = folder_paths.get_output_directory() + elif folder_type == "temp": + base_dir = folder_paths.get_temp_directory() + elif folder_type == "input": + base_dir = folder_paths.get_input_directory() + else: + base_dir = folder_paths.get_output_directory() + + if subfolder: + return os.path.join(base_dir, subfolder, filename) + return os.path.join(base_dir, filename) + + +def detect_output_type( + ui_output: dict, + node_id: Optional[str] = None, + node_type: Optional[str] = None +) -> list[OutputInfo]: + """ + Detect output type from ComfyUI UI return structure. + + Known UI structures: + - {"images": [{filename, subfolder, type}, ...]} + - {"audio": [{filename, subfolder, type}, ...]} + - {"video": [{filename, subfolder, type}, ...]} + - {"3d": [{filename, subfolder, type}, ...]} + - {"latents": [{filename, subfolder, type}, ...]} + - {"text": (value,)} or {"text": ["value"]} + - {"result": [model_file, camera_info, bg_image]} + + Args: + ui_output: The UI output dictionary from a node + node_id: Optional node ID for metadata + node_type: Optional node type for metadata + + Returns: + List of OutputInfo objects describing the outputs + """ + outputs = [] + + if not ui_output or not isinstance(ui_output, dict): + return outputs + + # Handle images + if "images" in ui_output: + images = ui_output["images"] + if isinstance(images, list): + for idx, item in enumerate(images): + if isinstance(item, dict) and "filename" in item: + info = _create_output_info_from_file( + item, "image", node_id, node_type + ) + outputs.append(info) + + # Handle audio + if "audio" in ui_output: + audio_items = ui_output["audio"] + if isinstance(audio_items, list): + for item in audio_items: + if isinstance(item, dict) and "filename" in item: + info = _create_output_info_from_file( + item, "audio", node_id, node_type + ) + outputs.append(info) + + # Handle video + if "video" in ui_output: + video_items = ui_output["video"] + if isinstance(video_items, list): + for item in video_items: + if isinstance(item, dict) and "filename" in item: + info = _create_output_info_from_file( + item, "video", node_id, node_type + ) + outputs.append(info) + + # Handle 3D meshes + if "3d" in ui_output: + mesh_items = ui_output["3d"] + if isinstance(mesh_items, list): + for item in mesh_items: + if isinstance(item, dict) and "filename" in item: + info = _create_output_info_from_file( + item, "mesh", node_id, node_type + ) + outputs.append(info) + + # Handle latents + if "latents" in ui_output: + latent_items = ui_output["latents"] + if isinstance(latent_items, list): + for item in latent_items: + if isinstance(item, dict) and "filename" in item: + info = _create_output_info_from_file( + item, "latent", node_id, node_type + ) + outputs.append(info) + + # Handle text outputs + if "text" in ui_output: + text_data = ui_output["text"] + if isinstance(text_data, tuple) and len(text_data) > 0: + # Text is often returned as a tuple + text_value = str(text_data[0]) + elif isinstance(text_data, list) and len(text_data) > 0: + text_value = str(text_data[0]) + elif isinstance(text_data, str): + text_value = text_data + else: + text_value = str(text_data) + + outputs.append(OutputInfo( + type="text", + inline_content=text_value, + mime_type="text/plain", + node_id=node_id, + node_type=node_type, + )) + + # Handle 3D preview (result structure) + if "result" in ui_output and "images" not in ui_output: + result_data = ui_output["result"] + outputs.append(OutputInfo( + type="3d_preview", + inline_content=json.dumps(result_data), + mime_type="application/json", + node_id=node_id, + node_type=node_type, + )) + + # Handle animated flag (for videos/GIFs saved as images) + if "animated" in ui_output: + # Mark the last image output as animated if applicable + for output in reversed(outputs): + if output.type == "image": + output.format = "animated" + break + + # Fallback: try to extract any file references from unknown structures + if not outputs: + outputs = _extract_unknown_outputs(ui_output, node_id, node_type) + + return outputs + + +def _create_output_info_from_file( + item: dict, + output_type: str, + node_id: Optional[str], + node_type: Optional[str] +) -> OutputInfo: + """Create OutputInfo from a file reference dictionary.""" + filename = item.get("filename", "") + subfolder = item.get("subfolder", "") + folder_type = item.get("type", "output") + + # Get file path and size + file_path = get_output_path(filename, subfolder, folder_type) + file_size = None + if os.path.exists(file_path): + file_size = os.path.getsize(file_path) + + return OutputInfo( + type=output_type, + filename=filename, + subfolder=subfolder, + folder_type=folder_type, + mime_type=guess_mime_type(filename), + format=get_format_from_filename(filename), + file_size_bytes=file_size, + node_id=node_id, + node_type=node_type, + ) + + +def _extract_unknown_outputs( + ui_output: dict, + node_id: Optional[str], + node_type: Optional[str] +) -> list[OutputInfo]: + """ + Extract outputs from unknown UI structures. + Looks for any dictionary with 'filename' key. + """ + outputs = [] + + for key, value in ui_output.items(): + if isinstance(value, list): + for item in value: + if isinstance(item, dict) and "filename" in item: + info = _create_output_info_from_file( + item, "unknown", node_id, node_type + ) + outputs.append(info) + logger.info( + f"Extracted unknown output type '{key}': {item.get('filename')}" + ) + + # If still no outputs, serialize the entire structure as JSON + if not outputs and ui_output: + logger.warning( + f"Unknown output format, serializing as JSON: {list(ui_output.keys())}" + ) + outputs.append(OutputInfo( + type="unknown", + inline_content=json.dumps(ui_output), + mime_type="application/json", + node_id=node_id, + node_type=node_type, + )) + + return outputs + + +def process_outputs_for_webhook( + outputs: dict, + meta: Optional[dict] = None +) -> list[OutputInfo]: + """ + Process all outputs from a workflow execution for webhook delivery. + + Args: + outputs: Dictionary mapping node_id -> UI output dict + meta: Optional metadata dict mapping node_id -> node metadata + + Returns: + List of all OutputInfo objects from all nodes + """ + all_outputs = [] + + for node_id, ui_output in outputs.items(): + # Get node type from metadata if available + node_type = None + if meta and node_id in meta: + node_meta = meta[node_id] + if isinstance(node_meta, dict): + node_type = node_meta.get("node_type") + + # Detect outputs for this node + node_outputs = detect_output_type(ui_output, node_id, node_type) + all_outputs.extend(node_outputs) + + return all_outputs + + +def load_output_file(output_info: OutputInfo) -> Optional[bytes]: + """ + Load the binary content of an output file. + + Args: + output_info: OutputInfo with file location details + + Returns: + File bytes or None if file doesn't exist + """ + if not output_info.filename: + return None + + file_path = get_output_path( + output_info.filename, + output_info.subfolder or "", + output_info.folder_type or "output" + ) + + if not os.path.exists(file_path): + logger.warning(f"Output file not found: {file_path}") + return None + + try: + with open(file_path, "rb") as f: + return f.read() + except Exception as e: + logger.error(f"Failed to read output file {file_path}: {e}") + return None + + +def get_image_dimensions(output_info: OutputInfo) -> tuple[Optional[int], Optional[int]]: + """ + Get dimensions of an image output. + + Args: + output_info: OutputInfo for an image + + Returns: + Tuple of (width, height) or (None, None) if unable to determine + """ + if output_info.type != "image" or not output_info.filename: + return None, None + + try: + from PIL import Image + + file_path = get_output_path( + output_info.filename, + output_info.subfolder or "", + output_info.folder_type or "output" + ) + + if os.path.exists(file_path): + with Image.open(file_path) as img: + return img.size # (width, height) + except Exception as e: + logger.warning(f"Failed to get image dimensions: {e}") + + return None, None + + +def enrich_output_info(output_info: OutputInfo) -> OutputInfo: + """ + Enrich OutputInfo with additional metadata. + + Adds dimensions for images, file size, etc. + + Args: + output_info: The OutputInfo to enrich + + Returns: + The same OutputInfo with additional fields populated + """ + # Get file size if not already set + if output_info.file_size_bytes is None and output_info.filename: + file_path = get_output_path( + output_info.filename, + output_info.subfolder or "", + output_info.folder_type or "output" + ) + if os.path.exists(file_path): + output_info.file_size_bytes = os.path.getsize(file_path) + + # Get image dimensions + if output_info.type == "image" and (output_info.width is None or output_info.height is None): + width, height = get_image_dimensions(output_info) + if width and height: + output_info.width = width + output_info.height = height + + return output_info diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..2fb1caf --- /dev/null +++ b/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +testpaths = tests +python_files = test_*.py +asyncio_mode = auto diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..d16ee03 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,18 @@ +# ComfyUI Workflow API - Dependencies + +# Required +aiohttp>=3.8.0 # Async HTTP client for webhook delivery + +# Optional - for enhanced validation (uncomment if desired) +# pydantic>=2.0.0 # Data validation and serialization + +# Development dependencies (install with: pip install -r requirements.txt[dev]) +# pytest>=7.0.0 # Testing framework +# pytest-asyncio>=0.21.0 # Async test support +# pytest-cov>=4.0.0 # Coverage reporting + +# Note: The following are typically already available in ComfyUI: +# - torch # Tensor operations +# - numpy # Array operations +# - Pillow # Image processing +# - av # Video encoding (for video output) diff --git a/run_tests.py b/run_tests.py new file mode 100644 index 0000000..9c071c8 --- /dev/null +++ b/run_tests.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +"""Run all tests.""" + +import subprocess +import sys +from pathlib import Path + +def main(): + test_dir = Path(__file__).parent / "tests" + test_files = list(test_dir.glob("test_*.py")) + + if not test_files: + print("No test files found") + return 1 + + failed = 0 + for test_file in test_files: + print(f"\n{'='*50}") + print(f"Running {test_file.name}") + print('='*50) + result = subprocess.run([sys.executable, str(test_file)], cwd=Path(__file__).parent) + if result.returncode != 0: + failed += 1 + + print(f"\n{'='*50}") + if failed: + print(f"FAILED: {failed} test file(s) had failures") + else: + print("All tests passed!") + return failed + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/sample_input.png b/sample_input.png new file mode 100644 index 0000000000000000000000000000000000000000..19c601719b59b032ecdf6ab145009d8b552fa69d GIT binary patch literal 388166 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%0ARvbtkz226bh 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%0Am}r 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%0A-@y*+}dml^C@q?d` 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

rqJHCmIXxNVk2za>s)*u3vINuc9qOB*- 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¬80oc|b2k85IAJ{mBO*50*Huj{}7bWF40e$$OS+ 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 NSgqRrF_l4~Hc#3fYPZq-l-I{| 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

{$VmH-EH;jYYBy>aUC-KkWw+vx9} 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%0DyKsLUA<=d!Rpvv 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 literal 0 HcmV?d00001 diff --git a/server/__init__.py b/server/__init__.py new file mode 100644 index 0000000..cfe7477 --- /dev/null +++ b/server/__init__.py @@ -0,0 +1,6 @@ +"""Server extension for ComfyUI webhook integration.""" + +from .routes import register_routes +from .uploads import save_upload, cleanup_uploads + +__all__ = ["register_routes", "save_upload", "cleanup_uploads"] diff --git a/server/routes.py b/server/routes.py new file mode 100644 index 0000000..fe26f55 --- /dev/null +++ b/server/routes.py @@ -0,0 +1,308 @@ +"""HTTP routes for webhook integration.""" + +import json +import logging +import uuid +from datetime import datetime +from typing import Optional + +from aiohttp import web + +logger = logging.getLogger(__name__) + + +def register_routes(): + """Register webhook routes with ComfyUI's PromptServer.""" + try: + from server import PromptServer + + routes = PromptServer.instance.routes + + @routes.post("/api/webhook") + async def webhook_submit(request): + """ + Submit a workflow via multipart/form-data. + + Fields: + - workflow: JSON workflow definition (required) + - callback_url: URL to receive events and outputs (required) + - auth_header: Auth header name (optional) + - auth_value: Auth header value (optional) + - timeout: HTTP timeout in seconds (optional, default: 60) + - max_retries: Max retry attempts (optional, default: 3) + - : Uploaded files, accessible by field name + - : Text fields, accessible by field name + + Returns: + - request_id: Unique identifier for this request + - prompt_id: ComfyUI prompt ID + - status: "queued" + """ + from .uploads import save_upload + + request_id = str(uuid.uuid4()) + + try: + # Parse multipart request + reader = await request.multipart() + + workflow = None + callback_url = None + auth_header = None + auth_value = None + timeout = 60 + max_retries = 3 + send_progress = True + progress_interval_ms = 500 + webhook_inputs = {} + + # Get request metadata + remote_ip = request.remote + content_type = request.content_type + content_length = request.content_length + user_agent = request.headers.get("User-Agent", "unknown") + + async for part in reader: + name = part.name + + if name == "workflow": + content = await part.text() + try: + workflow = json.loads(content) + except json.JSONDecodeError as e: + return web.json_response( + {"error": f"Invalid workflow JSON: {e}"}, + status=400 + ) + + elif name == "callback_url": + callback_url = await part.text() + + elif name == "auth_header": + auth_header = await part.text() + + elif name == "auth_value": + auth_value = await part.text() + + elif name == "timeout": + try: + timeout = int(await part.text()) + except ValueError: + pass + + elif name == "max_retries": + try: + max_retries = int(await part.text()) + except ValueError: + pass + + elif name == "send_progress": + value = await part.text() + send_progress = value.lower() in ("true", "1", "yes") + + elif name == "progress_interval_ms": + try: + progress_interval_ms = int(await part.text()) + except ValueError: + pass + + elif part.filename: + # File upload - save to disk and store path (not raw data to avoid serialization issues) + data = await part.read() + filename = part.filename + file_content_type = part.headers.get("Content-Type", "application/octet-stream") + + # Save to ComfyUI input directory + saved_path = save_upload(data, filename, request_id) + + # Store file metadata (path, not raw bytes) in webhook_inputs + webhook_inputs[name] = { + "_is_file": True, + "_filename": filename, + "_content_type": file_content_type, + "_saved_path": saved_path, + "_size_bytes": len(data), + } + logger.debug(f"Saved upload '{name}' ({len(data)} bytes) to {saved_path}") + + else: + # Text field + webhook_inputs[name] = await part.text() + + # Validate required fields + if workflow is None: + return web.json_response( + {"error": "Missing required field: workflow"}, + status=400 + ) + + if callback_url is None: + return web.json_response( + {"error": "Missing required field: callback_url"}, + status=400 + ) + + # Generate prompt_id + prompt_id = str(uuid.uuid4()) + + # Build webhook_config for extra_data + webhook_config = { + "callback_url": callback_url, + "auth_header": auth_header, + "auth_value": auth_value, + "request_id": request_id, + "timeout": timeout, + "max_retries": max_retries, + "send_progress": send_progress, + "progress_interval_ms": progress_interval_ms, + "remote_ip": remote_ip, + "content_type": content_type, + "content_length": content_length, + "user_agent": user_agent, + } + + # Build extra_data for workflow + # ComfyUI passes extra_data['extra_pnginfo'] to nodes with EXTRA_PNGINFO hidden input + extra_data = { + "webhook_config": webhook_config, + "webhook_inputs": webhook_inputs, + "extra_pnginfo": { + "webhook_config": webhook_config, + "webhook_inputs": webhook_inputs, + }, + } + + # Validate prompt and get outputs_to_execute + import execution + valid = await execution.validate_prompt(prompt_id, workflow, None) + + if not valid[0]: + # Validation failed + logger.warning(f"Invalid workflow: {valid[1]}") + return web.json_response( + {"error": valid[1], "node_errors": valid[3]}, + status=400 + ) + + outputs_to_execute = valid[2] + + # Register webhook context for progress tracking + from ..core.context import register_webhook_context + from ..core.types import WebhookContext + + context = WebhookContext( + request_id=request_id, + prompt_id=prompt_id, + callback_url=callback_url, + auth_header=auth_header, + auth_value=auth_value, + timeout=timeout, + max_retries=max_retries, + send_progress=send_progress, + progress_interval_ms=progress_interval_ms, + ) + register_webhook_context(context) + + # Queue the workflow + queue = PromptServer.instance.prompt_queue + + # ComfyUI expects: (priority, prompt_id, prompt, extra_data, outputs_to_execute, sensitive) + queue.put((0, prompt_id, workflow, extra_data, outputs_to_execute, {})) + + logger.info(f"Webhook request {request_id} queued as prompt {prompt_id}") + + return web.json_response({ + "request_id": request_id, + "prompt_id": prompt_id, + "status": "queued", + }) + + except Exception as e: + logger.error(f"Webhook submit error: {e}", exc_info=True) + return web.json_response( + {"error": str(e)}, + status=500 + ) + + @routes.get("/api/webhook/status/{request_id}") + async def webhook_status(request): + """ + Get status of a webhook request. + + Returns: + - request_id: The request ID + - prompt_id: ComfyUI prompt ID + - status: queued|running|completed|error|interrupted + - progress: Current progress info (if running) + - error: Error details (if error) + """ + from ..core.context import get_context + + request_id = request.match_info["request_id"] + context = get_context(request_id) + + if context is None: + return web.json_response( + {"error": "Request not found"}, + status=404 + ) + + response = { + "request_id": context.request_id, + "prompt_id": context.prompt_id, + "callback_url": context.callback_url, + "fields": context.get_field_names(), + } + + if context.start_time: + response["started_at"] = context.start_time.isoformat() + + if context.completed_at: + response["completed_at"] = context.completed_at.isoformat() + if context.start_time: + elapsed = (context.completed_at - context.start_time).total_seconds() * 1000 + response["execution_time_ms"] = elapsed + + return web.json_response(response) + + @routes.delete("/api/webhook/{request_id}") + async def webhook_cancel(request): + """Cancel a queued or running webhook request.""" + from ..core.context import get_context, update_context + + request_id = request.match_info["request_id"] + context = get_context(request_id) + + if context is None: + return web.json_response( + {"error": "Request not found"}, + status=404 + ) + + # Try to interrupt the execution + try: + if context.prompt_id: + PromptServer.instance.prompt_queue.delete_queue_item(context.prompt_id) + + update_context(request_id, completed_at=datetime.now()) + + return web.json_response({ + "request_id": request_id, + "status": "cancelled", + }) + except Exception as e: + logger.error(f"Failed to cancel request {request_id}: {e}") + return web.json_response( + {"error": str(e)}, + status=500 + ) + + logger.info("Webhook routes registered: POST /api/webhook, GET /api/webhook/status/{id}") + return True + + except ImportError as e: + logger.warning(f"Could not register webhook routes (ComfyUI server not available): {e}") + return False + except Exception as e: + logger.error(f"Failed to register webhook routes: {e}", exc_info=True) + return False diff --git a/server/uploads.py b/server/uploads.py new file mode 100644 index 0000000..b1c6993 --- /dev/null +++ b/server/uploads.py @@ -0,0 +1,187 @@ +"""Handle file uploads for webhook requests.""" + +import logging +import os +import shutil +import uuid +from pathlib import Path +from typing import Optional + +logger = logging.getLogger(__name__) + +# Track uploads per request for cleanup +_upload_registry: dict[str, list[str]] = {} + + +def get_upload_directory() -> str: + """Get the directory for webhook uploads.""" + try: + import folder_paths + # Use ComfyUI's input directory for uploads + input_dir = folder_paths.get_input_directory() + webhook_dir = os.path.join(input_dir, "webhook_uploads") + except ImportError: + # Fallback for testing + webhook_dir = os.path.join(os.getcwd(), "input", "webhook_uploads") + + os.makedirs(webhook_dir, exist_ok=True) + return webhook_dir + + +def save_upload(data: bytes, filename: str, request_id: str) -> str: + """ + Save an uploaded file to the webhook uploads directory. + + Args: + data: File content as bytes + filename: Original filename + request_id: Request ID for organizing uploads + + Returns: + Full path to the saved file + """ + upload_dir = get_upload_directory() + + # Create request-specific subdirectory + request_dir = os.path.join(upload_dir, request_id) + os.makedirs(request_dir, exist_ok=True) + + # Sanitize filename and make unique + safe_filename = sanitize_filename(filename) + base, ext = os.path.splitext(safe_filename) + + # Add short UUID to avoid collisions + unique_filename = f"{base}_{uuid.uuid4().hex[:8]}{ext}" + file_path = os.path.join(request_dir, unique_filename) + + # Write file + with open(file_path, "wb") as f: + f.write(data) + + # Track for cleanup + if request_id not in _upload_registry: + _upload_registry[request_id] = [] + _upload_registry[request_id].append(file_path) + + logger.debug(f"Saved upload: {file_path} ({len(data)} bytes)") + return file_path + + +def sanitize_filename(filename: str) -> str: + """Sanitize a filename for safe storage.""" + # Remove path separators and null bytes + filename = filename.replace("/", "_").replace("\\", "_").replace("\x00", "") + + # Remove leading dots (hidden files) + while filename.startswith("."): + filename = filename[1:] + + # Default name if empty + if not filename: + filename = "upload" + + # Limit length + if len(filename) > 200: + base, ext = os.path.splitext(filename) + filename = base[:200 - len(ext)] + ext + + return filename + + +def cleanup_uploads(request_id: str) -> int: + """ + Clean up uploaded files for a request. + + Args: + request_id: Request ID to clean up + + Returns: + Number of files removed + """ + count = 0 + + # Remove tracked files + if request_id in _upload_registry: + for file_path in _upload_registry[request_id]: + try: + if os.path.exists(file_path): + os.remove(file_path) + count += 1 + except Exception as e: + logger.warning(f"Failed to remove upload {file_path}: {e}") + + del _upload_registry[request_id] + + # Also try to remove the request directory + upload_dir = get_upload_directory() + request_dir = os.path.join(upload_dir, request_id) + + try: + if os.path.exists(request_dir): + shutil.rmtree(request_dir) + logger.debug(f"Removed upload directory: {request_dir}") + except Exception as e: + logger.warning(f"Failed to remove upload directory {request_dir}: {e}") + + return count + + +def get_upload_path(request_id: str, field_name: str) -> Optional[str]: + """ + Get the path to an uploaded file by field name. + + This is used by WebhookInput node to load files. + + Args: + request_id: Request ID + field_name: Field name from the upload + + Returns: + File path if found, None otherwise + """ + # This is primarily resolved via extra_data["webhook_uploads"] + # But we can search the registry as fallback + if request_id in _upload_registry: + for path in _upload_registry[request_id]: + if field_name in path: + return path + return None + + +def cleanup_old_uploads(max_age_hours: int = 24) -> int: + """ + Clean up old upload directories. + + Args: + max_age_hours: Remove directories older than this + + Returns: + Number of directories removed + """ + import time + + upload_dir = get_upload_directory() + if not os.path.exists(upload_dir): + return 0 + + count = 0 + cutoff = time.time() - (max_age_hours * 3600) + + try: + for entry in os.scandir(upload_dir): + if entry.is_dir(): + try: + mtime = entry.stat().st_mtime + if mtime < cutoff: + shutil.rmtree(entry.path) + count += 1 + logger.debug(f"Cleaned up old upload directory: {entry.path}") + except Exception as e: + logger.warning(f"Failed to clean up {entry.path}: {e}") + except Exception as e: + logger.warning(f"Failed to scan upload directory: {e}") + + if count > 0: + logger.info(f"Cleaned up {count} old upload directories") + + return count diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..74864ec --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,7 @@ +"""Pytest configuration.""" + +import sys +from pathlib import Path + +# Add parent directory to path for imports +sys.path.insert(0, str(Path(__file__).parent.parent)) diff --git a/tests/test_core.py b/tests/test_core.py new file mode 100644 index 0000000..97da314 --- /dev/null +++ b/tests/test_core.py @@ -0,0 +1,121 @@ +"""Core functionality tests.""" + +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).parent.parent)) + +from core.types import WebhookContext, WebhookField, WebhookEvent, WebhookResult, OutputInfo +from core.context import register_webhook_context, get_webhook_context, unregister_webhook_context + + +def test_context_defaults(): + ctx = WebhookContext() + assert ctx.callback_url == "" + assert ctx.timeout == 60 + assert ctx.max_retries == 3 + assert ctx.request_id + # start_time is None until register_webhook_context() is called + assert ctx.start_time is None + assert ctx.timestamp is not None + + +def test_context_with_values(): + ctx = WebhookContext( + callback_url="https://example.com/webhook", + auth_header="Authorization", + auth_value="Bearer token123", + timeout=30, + ) + assert ctx.callback_url == "https://example.com/webhook" + assert ctx.auth_header == "Authorization" + assert ctx.timeout == 30 + + +def test_auth_headers(): + ctx = WebhookContext(auth_header="X-API-Key", auth_value="secret") + assert ctx.get_auth_headers() == {"X-API-Key": "secret"} + + ctx_no_auth = WebhookContext() + assert ctx_no_auth.get_auth_headers() == {} + + +def test_field_access(): + field = WebhookField(name="prompt", value="hello world", size_bytes=11) + ctx = WebhookContext(fields={"prompt": field}) + + assert ctx.has_field("prompt") + assert not ctx.has_field("missing") + assert ctx.get_field("prompt") == field + assert ctx.get_field_value("prompt") == "hello world" + assert ctx.get_field_value("missing", "default") == "default" + + +def test_legacy_inputs(): + ctx = WebhookContext(inputs={"old_field": "old_value"}) + assert ctx.get_field_value("old_field") == "old_value" + assert ctx.has_field("old_field") + + +def test_censor_auth(): + ctx = WebhookContext(auth_header="Authorization", auth_value="Bearer secrettoken123") + censored = ctx.censor_auth() + assert "Bear" in censored + assert "123" in censored + assert "secrettoken" not in censored + + +def test_context_registry(): + ctx = WebhookContext(prompt_id="test-123", callback_url="https://example.com") + register_webhook_context(ctx) + assert get_webhook_context("test-123") is ctx + unregister_webhook_context("test-123") + assert get_webhook_context("test-123") is None + + +def test_output_info(): + info = OutputInfo(type="image", filename="test.png", width=1024, height=768) + d = info.to_dict() + assert d["type"] == "image" + assert d["filename"] == "test.png" + assert d["width"] == 1024 + + +def test_webhook_events(): + assert WebhookEvent.STARTED.value == "workflow.started" + assert WebhookEvent.COMPLETED.value == "workflow.completed" + assert WebhookEvent.ERROR.value == "workflow.error" + + +def run_all(): + tests = [ + test_context_defaults, + test_context_with_values, + test_auth_headers, + test_field_access, + test_legacy_inputs, + test_censor_auth, + test_context_registry, + test_output_info, + test_webhook_events, + ] + + passed = 0 + failed = 0 + + for test in tests: + try: + test() + print(f" PASS: {test.__name__}") + passed += 1 + except Exception as e: + print(f" FAIL: {test.__name__} - {e}") + failed += 1 + + print(f"\n{passed} passed, {failed} failed") + return failed == 0 + + +if __name__ == "__main__": + print("Running core tests...") + success = run_all() + sys.exit(0 if success else 1) diff --git a/utils/__init__.py b/utils/__init__.py new file mode 100644 index 0000000..56c1bf0 --- /dev/null +++ b/utils/__init__.py @@ -0,0 +1,16 @@ +"""Utility functions for webhook functionality.""" + +from .mime import guess_mime_type, get_extension_for_mime, MIME_TYPES +from .files import get_output_path, get_image_dimensions, get_temp_directory +from .helpers import format_size, run_async + +__all__ = [ + "guess_mime_type", + "get_extension_for_mime", + "MIME_TYPES", + "get_output_path", + "get_image_dimensions", + "get_temp_directory", + "format_size", + "run_async", +] diff --git a/utils/files.py b/utils/files.py new file mode 100644 index 0000000..02a2265 --- /dev/null +++ b/utils/files.py @@ -0,0 +1,192 @@ +"""File path resolution and utilities.""" + +import logging +import os +from typing import Optional, Tuple + +logger = logging.getLogger(__name__) + + +def get_output_path( + filename: str, + subfolder: str = "", + folder_type: str = "output" +) -> str: + """ + Resolve the full path to an output file. + + Args: + filename: Name of the file + subfolder: Subfolder within the directory + folder_type: Type of folder (output, temp, input) + + Returns: + Full filesystem path to the file + """ + try: + import folder_paths + + if folder_type == "output": + base_dir = folder_paths.get_output_directory() + elif folder_type == "temp": + base_dir = folder_paths.get_temp_directory() + elif folder_type == "input": + base_dir = folder_paths.get_input_directory() + else: + base_dir = folder_paths.get_output_directory() + + except ImportError: + # Fallback if folder_paths not available + base_dir = os.path.join(os.getcwd(), folder_type) + + if subfolder: + return os.path.join(base_dir, subfolder, filename) + return os.path.join(base_dir, filename) + + +def get_image_dimensions(file_path: str) -> Tuple[Optional[int], Optional[int]]: + """ + Get dimensions of an image file. + + Args: + file_path: Path to the image file + + Returns: + Tuple of (width, height) or (None, None) if unable to determine + """ + if not os.path.exists(file_path): + return None, None + + try: + from PIL import Image + with Image.open(file_path) as img: + return img.size # (width, height) + except ImportError: + logger.debug("PIL not available for image dimension detection") + except Exception as e: + logger.debug(f"Failed to get image dimensions: {e}") + + return None, None + + +def get_temp_directory() -> str: + """Get the webhook temp directory.""" + try: + import folder_paths + temp_dir = folder_paths.get_temp_directory() + except ImportError: + temp_dir = os.path.join(os.getcwd(), "temp") + + webhook_temp = os.path.join(temp_dir, "webhook") + os.makedirs(webhook_temp, exist_ok=True) + return webhook_temp + + +def save_temp_file(data: bytes, filename: str, request_id: str = "") -> str: + """ + Save data to a temp file. + + Args: + data: File content + filename: Filename to use + request_id: Optional request ID for organization + + Returns: + Path to saved file + """ + temp_dir = get_temp_directory() + + if request_id: + subdir = os.path.join(temp_dir, request_id) + os.makedirs(subdir, exist_ok=True) + file_path = os.path.join(subdir, filename) + else: + file_path = os.path.join(temp_dir, filename) + + with open(file_path, "wb") as f: + f.write(data) + + return file_path + + +def cleanup_temp_files(request_id: str) -> int: + """ + Clean up temp files for a request. + + Args: + request_id: Request ID + + Returns: + Number of files removed + """ + import shutil + + temp_dir = get_temp_directory() + subdir = os.path.join(temp_dir, request_id) + + if not os.path.exists(subdir): + return 0 + + try: + count = len(os.listdir(subdir)) + shutil.rmtree(subdir) + return count + except Exception as e: + logger.warning(f"Failed to clean up temp files: {e}") + return 0 + + +def detect_file_type(file_path: str) -> Optional[str]: + """ + Detect file type from magic bytes. + + Args: + file_path: Path to file + + Returns: + Detected type: "image", "audio", "video", "3d", or None + """ + if not os.path.exists(file_path): + return None + + try: + with open(file_path, "rb") as f: + header = f.read(32) + except Exception: + return None + + # Image formats + if header.startswith(b"\x89PNG"): + return "image" + if header.startswith(b"\xff\xd8\xff"): + return "image" + if header.startswith(b"RIFF") and b"WEBP" in header[:16]: + return "image" + if header.startswith(b"GIF8"): + return "image" + if header.startswith(b"BM"): + return "image" + + # Audio formats + if header.startswith(b"fLaC"): + return "audio" + if header.startswith(b"RIFF") and b"WAVE" in header[:16]: + return "audio" + if header.startswith(b"ID3") or header.startswith(b"\xff\xfb"): + return "audio" + if header.startswith(b"OggS"): + return "audio" + + # Video formats + if header[4:8] == b"ftyp": # MP4/MOV + return "video" + if header.startswith(b"\x1a\x45\xdf\xa3"): # WebM/MKV + return "video" + + # 3D formats + if header.startswith(b"glTF"): + return "3d" + if b"solid " in header.lower() or header.startswith(b"\x00"): # STL + return "3d" + + return None diff --git a/utils/helpers.py b/utils/helpers.py new file mode 100644 index 0000000..e0bba63 --- /dev/null +++ b/utils/helpers.py @@ -0,0 +1,30 @@ +"""Shared helper functions.""" + +import asyncio +import concurrent.futures + + +def format_size(size_bytes: int) -> str: + """Format bytes as human readable.""" + if size_bytes is None: + return "unknown" + if size_bytes < 1024: + return f"{size_bytes} bytes" + elif size_bytes < 1024 * 1024: + return f"{size_bytes / 1024:.1f} KB" + else: + return f"{size_bytes / (1024 * 1024):.1f} MB" + + +def run_async(coro): + """Run an async coroutine in sync context.""" + try: + loop = asyncio.get_event_loop() + if loop.is_running(): + with concurrent.futures.ThreadPoolExecutor() as executor: + future = executor.submit(asyncio.run, coro) + return future.result() + else: + return loop.run_until_complete(coro) + except RuntimeError: + return asyncio.run(coro) diff --git a/utils/mime.py b/utils/mime.py new file mode 100644 index 0000000..32153f8 --- /dev/null +++ b/utils/mime.py @@ -0,0 +1,141 @@ +"""MIME type utilities for webhook file handling.""" + +import os +from typing import Optional + +# Comprehensive MIME type mappings for ComfyUI output types +MIME_TYPES = { + # Images + ".png": "image/png", + ".jpg": "image/jpeg", + ".jpeg": "image/jpeg", + ".webp": "image/webp", + ".gif": "image/gif", + ".bmp": "image/bmp", + ".tiff": "image/tiff", + ".tif": "image/tiff", + + # Audio + ".flac": "audio/flac", + ".mp3": "audio/mpeg", + ".wav": "audio/wav", + ".ogg": "audio/ogg", + ".opus": "audio/opus", + ".m4a": "audio/mp4", + ".aac": "audio/aac", + + # Video + ".mp4": "video/mp4", + ".webm": "video/webm", + ".mov": "video/quicktime", + ".avi": "video/x-msvideo", + ".mkv": "video/x-matroska", + + # 3D Models + ".glb": "model/gltf-binary", + ".gltf": "model/gltf+json", + ".obj": "text/plain", + ".stl": "model/stl", + ".fbx": "application/octet-stream", + ".ply": "application/octet-stream", + + # Data/Other + ".json": "application/json", + ".safetensors": "application/octet-stream", + ".pt": "application/octet-stream", + ".pth": "application/octet-stream", + ".ckpt": "application/octet-stream", + ".latent": "application/octet-stream", + ".txt": "text/plain", + ".csv": "text/csv", +} + +# Reverse mapping for getting extension from MIME type +EXTENSION_FOR_MIME = { + "image/png": ".png", + "image/jpeg": ".jpg", + "image/webp": ".webp", + "image/gif": ".gif", + "audio/flac": ".flac", + "audio/mpeg": ".mp3", + "audio/wav": ".wav", + "audio/ogg": ".ogg", + "audio/opus": ".opus", + "video/mp4": ".mp4", + "video/webm": ".webm", + "model/gltf-binary": ".glb", + "model/gltf+json": ".gltf", + "application/json": ".json", + "text/plain": ".txt", +} + + +def guess_mime_type(filename: str) -> str: + """ + Guess MIME type from filename extension. + + Args: + filename: Filename with extension + + Returns: + MIME type string, defaults to "application/octet-stream" + """ + if not filename: + return "application/octet-stream" + + ext = os.path.splitext(filename.lower())[1] + return MIME_TYPES.get(ext, "application/octet-stream") + + +def get_extension_for_mime(mime_type: str) -> Optional[str]: + """ + Get file extension for a MIME type. + + Args: + mime_type: MIME type string + + Returns: + File extension including dot, or None if unknown + """ + return EXTENSION_FOR_MIME.get(mime_type) + + +def get_output_type_from_mime(mime_type: str) -> str: + """ + Determine output type category from MIME type. + + Args: + mime_type: MIME type string + + Returns: + Output type: image, audio, video, mesh, text, or unknown + """ + if mime_type.startswith("image/"): + return "image" + elif mime_type.startswith("audio/"): + return "audio" + elif mime_type.startswith("video/"): + return "video" + elif mime_type.startswith("model/") or mime_type in ("application/octet-stream",): + # Check if it's a known 3D format + return "mesh" + elif mime_type.startswith("text/") or mime_type == "application/json": + return "text" + else: + return "unknown" + + +def get_format_from_filename(filename: str) -> Optional[str]: + """ + Extract format (extension without dot) from filename. + + Args: + filename: Filename with extension + + Returns: + Format string (e.g., "png", "mp3") or None + """ + if not filename: + return None + ext = os.path.splitext(filename.lower())[1] + return ext[1:] if ext else None diff --git a/utils/validation.py b/utils/validation.py new file mode 100644 index 0000000..789b24a --- /dev/null +++ b/utils/validation.py @@ -0,0 +1,191 @@ +"""Validation utilities for webhook functionality.""" + +import re +import ipaddress +import logging +from urllib.parse import urlparse +from typing import Optional + +logger = logging.getLogger(__name__) + +# Regex for data URL detection +DATA_URL_PATTERN = re.compile(r'^data:([^;,]+)?(;base64)?,(.*)$', re.DOTALL) +URL_PATTERN = re.compile(r'^https?://') + + +def validate_url( + url: str, + require_https: bool = False, + block_private_ips: bool = False, +) -> tuple[bool, Optional[str]]: + """ + Validate a webhook URL for safety and correctness. + + Args: + url: URL to validate + require_https: If True, only allow HTTPS URLs + block_private_ips: If True, block private/local IP addresses + + Returns: + Tuple of (is_valid, error_message) + """ + if not url: + return False, "URL is empty" + + try: + parsed = urlparse(url) + + # Check scheme + if parsed.scheme not in ("http", "https"): + return False, f"Invalid URL scheme: {parsed.scheme}" + + if require_https and parsed.scheme != "https": + return False, "HTTPS is required" + + # Check host + if not parsed.netloc: + return False, "URL has no host" + + # Check for private IPs if requested + if block_private_ips: + hostname = parsed.hostname + if hostname: + # Check for localhost + if hostname in ("localhost", "127.0.0.1", "::1"): + return False, "Localhost URLs are not allowed" + + # Check for private IP ranges + try: + ip = ipaddress.ip_address(hostname) + if ip.is_private or ip.is_loopback or ip.is_link_local: + return False, "Private IP addresses are not allowed" + except ValueError: + # Not an IP address, hostname is fine + pass + + return True, None + + except Exception as e: + return False, f"URL parsing error: {str(e)}" + + +def sanitize_for_logging(data: dict, sensitive_keys: Optional[set] = None) -> dict: + """ + Sanitize a dictionary for safe logging by redacting sensitive values. + + Args: + data: Dictionary to sanitize + sensitive_keys: Set of key names to redact (case-insensitive) + + Returns: + Sanitized copy of the dictionary + """ + if sensitive_keys is None: + sensitive_keys = { + "auth_value", + "authorization", + "api_key", + "apikey", + "token", + "password", + "secret", + "credential", + "bearer", + } + + def redact_value(key: str, value): + if isinstance(value, dict): + return {k: redact_value(k, v) for k, v in value.items()} + elif isinstance(value, list): + return [redact_value(key, item) for item in value] + elif isinstance(value, str): + # Check if key is sensitive + if key.lower() in sensitive_keys: + return "[REDACTED]" + # Check if value looks like base64 data (long strings) + if len(value) > 100 and is_base64_data(value): + return f"[BASE64_DATA: {len(value)} chars]" + return value + + return {k: redact_value(k, v) for k, v in data.items()} + + +def is_base64_data(value: str) -> bool: + """ + Check if a string appears to be base64 encoded data. + + Args: + value: String to check + + Returns: + True if the string looks like base64 data + """ + # Check for data URL prefix + if value.startswith("data:"): + return True + + # Check for base64 character pattern (rough check) + # Base64 uses A-Z, a-z, 0-9, +, /, and = for padding + if len(value) > 50 and re.match(r'^[A-Za-z0-9+/]+=*$', value): + return True + + return False + + +def is_url(value: str) -> bool: + """ + Check if a string is an HTTP(S) URL. + + Args: + value: String to check + + Returns: + True if the string is a valid URL + """ + return bool(URL_PATTERN.match(value)) + + +def is_data_url(value: str) -> bool: + """ + Check if a string is a data URL. + + Args: + value: String to check + + Returns: + True if the string is a data URL + """ + return bool(DATA_URL_PATTERN.match(value)) + + +def parse_data_url(value: str) -> tuple[Optional[str], Optional[bytes]]: + """ + Parse a data URL and extract the content. + + Args: + value: Data URL string + + Returns: + Tuple of (mime_type, decoded_bytes) or (None, None) if invalid + """ + import base64 + + match = DATA_URL_PATTERN.match(value) + if not match: + return None, None + + mime_type = match.group(1) or "application/octet-stream" + is_base64 = match.group(2) is not None + data = match.group(3) + + try: + if is_base64: + decoded = base64.b64decode(data) + else: + # URL-encoded data + from urllib.parse import unquote + decoded = unquote(data).encode() + return mime_type, decoded + except Exception as e: + logger.warning(f"Failed to parse data URL: {e}") + return None, None