Merge branch 'main' into dev

* fix(image upload): skip when using the CD_BYPASS_UPLOAD env var

* Revert "fix(image upload): skip when using the CD_BYPASS_UPLOAD env var"

This reverts commit 384eda63e6.

* fix(upload outputs): skip images/gifs/files/mesh when env var is true

The env var is `CD_BYPASS_UPLOAD`.
When that variables is `True`, we don't upload the media to our comfy
deploy s3 bucket.

There are 2 steps.
1. save the file into our s3 bucket
2. save the saving into our database.

When `CD_BYPASS_UPLOAD` is True:
1. Skip the save file into our s3 bucket
2. Skip the save into our database

Previously we were skipping the step 1, but not the step 2. So that is
the reason of why we keep seeing the comfy deploy URL when fetching the
run details:

```
outputs: [
  {
    data:{
      gifs: [
        {
          url: "https://comfy-deploy-output.s3.amazonaws.com/video.mp4"
        }
      ],
      text: [
        "A text that you displayed with show text node"
      ]
    }
  }
]
```

With the new changes we don't save that into our database, and fetching
the details of a run will look like this:
```
outputs: [
  {
    data:{
      text: [
        "A text that you displayed with show text node"
      ]
    }
  }
]
```

.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

comfy-nodes/external_boolean.py

@@ -0,0 +1,25 @@
+class ComfyUIDeployExternalBoolean:
+    @classmethod    
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_bool"},
+                ),
+                "default_value": ("BOOLEAN", {"default": False})
+            }
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    RETURN_NAMES = ("bool_value",)
+    
+    FUNCTION = "run"
+    
+    def run(self, input_id, default_value=None):
+        print(f"Node '{input_id}' processing with switch set to {default_value}")
+        return [default_value]
+    
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalBoolean": ComfyUIDeployExternalBoolean}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalBoolean": "External Boolean (ComfyUI Deploy)"}

comfy-nodes/external_image_batch.py

@@ -0,0 +1,85 @@
+import folder_paths
+from PIL import Image, ImageOps
+import numpy as np
+import torch
+import json
+import comfy
+
+class ComfyUIDeployExternalImageBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_images"},
+                ),
+                "images": (
+                    "STRING",
+                    {"multiline": False, "default": "[]"},
+                ),
+            },
+            "optional": {
+                "default_value": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "image"
+    
+    def run(self, input_id, images=None, default_value=None):
+        processed_images = []
+        try:
+            images_list = json.loads(images)  # Assuming images is a JSON array string
+            print(images_list)
+            for img_input in images_list:
+                if img_input.startswith('http'):
+                    import requests
+                    from io import BytesIO
+                    print("Fetching image from url: ", img_input)
+                    response = requests.get(img_input)
+                    image = Image.open(BytesIO(response.content))
+                elif img_input.startswith('data:image/png;base64,') or img_input.startswith('data:image/jpeg;base64,') or img_input.startswith('data:image/jpg;base64,'):
+                    import base64
+                    from io import BytesIO
+                    print("Decoding base64 image")
+                    base64_image = img_input[img_input.find(",")+1:]
+                    decoded_image = base64.b64decode(base64_image)
+                    image = Image.open(BytesIO(decoded_image))
+                else:
+                    raise ValueError("Invalid image url or base64 data provided.")
+
+                image = ImageOps.exif_transpose(image)
+                image = image.convert("RGB")
+                image = np.array(image).astype(np.float32) / 255.0
+                image_tensor = torch.from_numpy(image)[None,]
+                processed_images.append(image_tensor)
+        except Exception as e:
+            print(f"Error processing images: {e}")
+            pass
+            
+        if default_value is not None and len(images_list) == 0:
+            processed_images.append(default_value)  # Assuming default_value is a pre-processed image tensor
+
+        # Resize images if necessary and concatenate from MakeImageBatch in ImpactPack
+        if processed_images:
+            base_shape = processed_images[0].shape[1:]  # Get the shape of the first image for comparison
+            batch_tensor = processed_images[0]
+            for i in range(1, len(processed_images)):
+                if processed_images[i].shape[1:] != base_shape:
+                    # Resize to match the first image's dimensions
+                    processed_images[i] = comfy.utils.common_upscale(processed_images[i].movedim(-1, 1), base_shape[1], base_shape[0], "lanczos", "center").movedim(1, -1)
+
+                batch_tensor = torch.cat((batch_tensor, processed_images[i]), dim=0)
+            # Concatenate using torch.cat
+        else:
+            batch_tensor = None  # or handle the empty case as needed
+        return (batch_tensor, )
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalImageBatch": ComfyUIDeployExternalImageBatch}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalImageBatch": "External Image Batch (ComfyUI Deploy)"}

comfy-nodes/external_lora.py

@@ -17,7 +17,7 @@ class ComfyUIDeployExternalLora:
             },
             "optional": {
                 "default_lora_name": (folder_paths.get_filename_list("loras"),),
-            }
+            },
         }
 
     RETURN_TYPES = (folder_paths.get_filename_list("loras"),)
@@ -32,20 +32,29 @@ class ComfyUIDeployExternalLora:
         import os
         import uuid
 
-        if input_id and input_id.startswith('http'):
+        if default_lora_name.startswith("http"):
             unique_filename = str(uuid.uuid4()) + ".safetensors"
             print(unique_filename)
             print(folder_paths.folder_names_and_paths["loras"][0][0])
-            destination_path = os.path.join(folder_paths.folder_names_and_paths["loras"][0][0], unique_filename)
+            destination_path = os.path.join(
+                folder_paths.folder_names_and_paths["loras"][0][0], unique_filename
+            )
             print(destination_path)
             print("Downloading external lora - " + input_id + " to " + destination_path)
-            response = requests.get(input_id, headers={'User-Agent': 'Mozilla/5.0'}, allow_redirects=True)
-            with open(destination_path, 'wb') as out_file:
+            response = requests.get(
+                input_id,
+                headers={"User-Agent": "Mozilla/5.0"},
+                allow_redirects=True,
+            )
+            with open(destination_path, "wb") as out_file:
                 out_file.write(response.content)
             return (unique_filename,)
         else:
+            print(f"using lora: {default_lora_name}")
             return (default_lora_name,)
 
 
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalLora": ComfyUIDeployExternalLora}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalLora": "External Lora (ComfyUI Deploy)"}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalLora": "External Lora (ComfyUI Deploy)"
+}

comfy-nodes/external_number_int.py

@@ -29,7 +29,7 @@ class ComfyUIDeployExternalNumberInt:
     CATEGORY = "number"
 
     def run(self, input_id, default_value=None):
-        if not input_id or not input_id.strip().isdigit():
+        if not input_id or (isinstance(input_id, str) and not input_id.strip().isdigit()):
             return [default_value]
         return [int(input_id)]
 

comfy-nodes/external_number_slider.py

@@ -0,0 +1,48 @@
+class ComfyUIDeployExternalNumberSlider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_number_slider"},
+                ),
+            },
+            "optional": {
+                "default_value": (
+                    "FLOAT",
+                    {"multiline": True, "display": "number", "default": 0.5, "step": 0.01},
+                ),
+                "min_value": (
+                    "FLOAT",
+                    {"multiline": True, "display": "number", "default": 0, "step": 0.01},
+                ),
+                "max_value": (
+                    "FLOAT",
+                    {"multiline": True, "display": "number", "default": 1, "step": 0.01},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    RETURN_NAMES = ("value",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "number"
+
+    def run(self, input_id, default_value=None, min_value=0, max_value=1):
+        try:
+            float_value = float(input_id)
+            if min_value <= float_value <= max_value:
+                print("my number", float_value)
+                return [float_value]
+            else:
+                print("Number out of range. Returning default value:", default_value)
+                return [default_value]
+        except ValueError:
+            print("Invalid input. Returning default value:", default_value)
+            return [default_value]
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalNumberSlider": ComfyUIDeployExternalNumberSlider}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalNumberSlider": "External Number Slider (ComfyUI Deploy)"}

comfy-nodes/external_vid.py

@@ -0,0 +1,78 @@
+import os
+import folder_paths
+import uuid
+
+from tqdm import tqdm
+
+video_extensions = ["webm", "mp4", "mkv", "gif"]
+
+
+class ComfyUIDeployExternalVideo:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        files = []
+        for f in os.listdir(input_dir):
+            if os.path.isfile(os.path.join(input_dir, f)):
+                file_parts = f.split(".")
+                if len(file_parts) > 1 and (file_parts[-1] in video_extensions):
+                    files.append(f)
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_video"},
+                ),
+            },
+            "optional": {
+                "meta_batch": ("VHS_BatchManager",),
+                "default_value": (sorted(files),),
+            },
+        }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("video")
+
+    FUNCTION = "load_video"
+
+    def load_video(self, input_id, default_value):
+        input_dir = folder_paths.get_input_directory()
+        if input_id.startswith("http"):
+            import requests
+
+            print("Fetching video from URL: ", input_id)
+            response = requests.get(input_id, stream=True)
+            file_size = int(response.headers.get("Content-Length", 0))
+            file_extension = input_id.split(".")[-1].split("?")[
+                0
+            ]  # Extract extension and handle URLs with parameters
+            if file_extension not in video_extensions:
+                file_extension = ".mp4"
+
+            unique_filename = str(uuid.uuid4()) + "." + file_extension
+            video_path = os.path.join(input_dir, unique_filename)
+            chunk_size = 1024  # 1 Kibibyte
+
+            num_bars = int(file_size / chunk_size)
+
+            with open(video_path, "wb") as out_file:
+                for chunk in tqdm(
+                    response.iter_content(chunk_size=chunk_size),
+                    total=num_bars,
+                    unit="KB",
+                    desc="Downloading",
+                    leave=True,
+                ):
+                    out_file.write(chunk)
+        else:
+            video_path = os.path.abspath(os.path.join(input_dir, default_value))
+
+        return (video_path,)
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalVid": ComfyUIDeployExternalVideo}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalVid": "External Video (ComfyUI Deploy) path"
+}

comfy-nodes/external_video.py

@@ -0,0 +1,594 @@
+# credit goes to https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite and is meant to work with
+import os
+import itertools
+import numpy as np
+import torch
+import cv2
+
+import folder_paths
+from comfy.utils import common_upscale
+
+### Utils
+import hashlib
+from typing import Iterable
+import shutil
+import subprocess
+import re
+import uuid
+
+import server
+from tqdm import tqdm
+
+BIGMIN = -(2**53 - 1)
+BIGMAX = 2**53 - 1
+
+DIMMAX = 8192
+
+
+def ffmpeg_suitability(path):
+    try:
+        version = subprocess.run(
+            [path, "-version"], check=True, capture_output=True
+        ).stdout.decode("utf-8")
+    except:
+        return 0
+    score = 0
+    # rough layout of the importance of various features
+    simple_criterion = [
+        ("libvpx", 20),
+        ("264", 10),
+        ("265", 3),
+        ("svtav1", 5),
+        ("libopus", 1),
+    ]
+    for criterion in simple_criterion:
+        if version.find(criterion[0]) >= 0:
+            score += criterion[1]
+    # obtain rough compile year from copyright information
+    copyright_index = version.find("2000-2")
+    if copyright_index >= 0:
+        copyright_year = version[copyright_index + 6 : copyright_index + 9]
+        if copyright_year.isnumeric():
+            score += int(copyright_year)
+    return score
+
+
+if "VHS_FORCE_FFMPEG_PATH" in os.environ:
+    ffmpeg_path = os.environ.get("VHS_FORCE_FFMPEG_PATH")
+else:
+    ffmpeg_paths = []
+    try:
+        from imageio_ffmpeg import get_ffmpeg_exe
+
+        imageio_ffmpeg_path = get_ffmpeg_exe()
+        ffmpeg_paths.append(imageio_ffmpeg_path)
+    except:
+        if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
+            raise
+    if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
+        ffmpeg_path = imageio_ffmpeg_path
+    else:
+        system_ffmpeg = shutil.which("ffmpeg")
+        if system_ffmpeg is not None:
+            ffmpeg_paths.append(system_ffmpeg)
+        if os.path.isfile("ffmpeg"):
+            ffmpeg_paths.append(os.path.abspath("ffmpeg"))
+        if os.path.isfile("ffmpeg.exe"):
+            ffmpeg_paths.append(os.path.abspath("ffmpeg.exe"))
+        if len(ffmpeg_paths) == 0:
+            ffmpeg_path = None
+        elif len(ffmpeg_paths) == 1:
+            # Evaluation of suitability isn't required, can take sole option
+            # to reduce startup time
+            ffmpeg_path = ffmpeg_paths[0]
+        else:
+            ffmpeg_path = max(ffmpeg_paths, key=ffmpeg_suitability)
+gifski_path = os.environ.get("VHS_GIFSKI", None)
+if gifski_path is None:
+    gifski_path = os.environ.get("JOV_GIFSKI", None)
+    if gifski_path is None:
+        gifski_path = shutil.which("gifski")
+
+
+def get_sorted_dir_files_from_directory(
+    directory: str,
+    skip_first_images: int = 0,
+    select_every_nth: int = 1,
+    extensions: Iterable = None,
+):
+    directory = directory.strip()
+    dir_files = os.listdir(directory)
+    dir_files = sorted(dir_files)
+    dir_files = [os.path.join(directory, x) for x in dir_files]
+    dir_files = list(filter(lambda filepath: os.path.isfile(filepath), dir_files))
+    # filter by extension, if needed
+    if extensions is not None:
+        extensions = list(extensions)
+        new_dir_files = []
+        for filepath in dir_files:
+            ext = "." + filepath.split(".")[-1]
+            if ext.lower() in extensions:
+                new_dir_files.append(filepath)
+        dir_files = new_dir_files
+    # start at skip_first_images
+    dir_files = dir_files[skip_first_images:]
+    dir_files = dir_files[0::select_every_nth]
+    return dir_files
+
+
+# modified from https://stackoverflow.com/questions/22058048/hashing-a-file-in-python
+def calculate_file_hash(filename: str, hash_every_n: int = 1):
+    # Larger video files were taking >.5 seconds to hash even when cached,
+    # so instead the modified time from the filesystem is used as a hash
+    h = hashlib.sha256()
+    h.update(filename.encode())
+    h.update(str(os.path.getmtime(filename)).encode())
+    return h.hexdigest()
+
+
+prompt_queue = server.PromptServer.instance.prompt_queue
+
+
+def requeue_workflow_unchecked():
+    """Requeues the current workflow without checking for multiple requeues"""
+    currently_running = prompt_queue.currently_running
+    (_, _, prompt, extra_data, outputs_to_execute) = next(
+        iter(currently_running.values())
+    )
+
+    # Ensure batch_managers are marked stale
+    prompt = prompt.copy()
+    for uid in prompt:
+        if prompt[uid]["class_type"] == "VHS_BatchManager":
+            prompt[uid]["inputs"]["requeue"] = (
+                prompt[uid]["inputs"].get("requeue", 0) + 1
+            )
+
+    # execution.py has guards for concurrency, but server doesn't.
+    # TODO: Check that this won't be an issue
+    number = -server.PromptServer.instance.number
+    server.PromptServer.instance.number += 1
+    prompt_id = str(server.uuid.uuid4())
+    prompt_queue.put((number, prompt_id, prompt, extra_data, outputs_to_execute))
+
+
+requeue_guard = [None, 0, 0, {}]
+
+
+def requeue_workflow(requeue_required=(-1, True)):
+    assert len(prompt_queue.currently_running) == 1
+    global requeue_guard
+    (run_number, _, prompt, _, _) = next(iter(prompt_queue.currently_running.values()))
+    if requeue_guard[0] != run_number:
+        # Calculate a count of how many outputs are managed by a batch manager
+        managed_outputs = 0
+        for bm_uid in prompt:
+            if prompt[bm_uid]["class_type"] == "VHS_BatchManager":
+                for output_uid in prompt:
+                    if prompt[output_uid]["class_type"] in ["VHS_VideoCombine"]:
+                        for inp in prompt[output_uid]["inputs"].values():
+                            if inp == [bm_uid, 0]:
+                                managed_outputs += 1
+        requeue_guard = [run_number, 0, managed_outputs, {}]
+    requeue_guard[1] = requeue_guard[1] + 1
+    requeue_guard[3][requeue_required[0]] = requeue_required[1]
+    if requeue_guard[1] == requeue_guard[2] and max(requeue_guard[3].values()):
+        requeue_workflow_unchecked()
+
+
+def get_audio(file, start_time=0, duration=0):
+    args = [ffmpeg_path, "-v", "error", "-i", file]
+    if start_time > 0:
+        args += ["-ss", str(start_time)]
+    if duration > 0:
+        args += ["-t", str(duration)]
+    try:
+        res = subprocess.run(
+            args + ["-f", "wav", "-"], stdout=subprocess.PIPE, check=True
+        ).stdout
+    except subprocess.CalledProcessError as e:
+        return False
+    return res
+
+
+def lazy_eval(func):
+    class Cache:
+        def __init__(self, func):
+            self.res = None
+            self.func = func
+
+        def get(self):
+            if self.res is None:
+                self.res = self.func()
+            return self.res
+
+    cache = Cache(func)
+    return lambda: cache.get()
+
+
+def is_url(url):
+    return url.split("://")[0] in ["http", "https"]
+
+
+def validate_sequence(path):
+    # Check if path is a valid ffmpeg sequence that points to at least one file
+    (path, file) = os.path.split(path)
+    if not os.path.isdir(path):
+        return False
+    match = re.search("%0?\d+d", file)
+    if not match:
+        return False
+    seq = match.group()
+    if seq == "%d":
+        seq = "\\\\d+"
+    else:
+        seq = "\\\\d{%s}" % seq[1:-1]
+    file_matcher = re.compile(re.sub("%0?\d+d", seq, file))
+    for file in os.listdir(path):
+        if file_matcher.fullmatch(file):
+            return True
+    return False
+
+
+def hash_path(path):
+    if path is None:
+        return "input"
+    if is_url(path):
+        return "url"
+    return calculate_file_hash(path.strip('"'))
+
+
+def validate_path(path, allow_none=False, allow_url=True):
+    if path is None:
+        return allow_none
+    if is_url(path):
+        # Probably not feasible to check if url resolves here
+        return True if allow_url else "URLs are unsupported for this path"
+    if not os.path.isfile(path.strip('"')):
+        return "Invalid file path: {}".format(path)
+    return True
+
+
+### Utils
+
+video_extensions = ["webm", "mp4", "mkv", "gif"]
+
+
+def is_gif(filename) -> bool:
+    file_parts = filename.split(".")
+    return len(file_parts) > 1 and file_parts[-1] == "gif"
+
+
+def target_size(
+    width, height, force_size, custom_width, custom_height
+) -> tuple[int, int]:
+    if force_size == "Custom":
+        return (custom_width, custom_height)
+    elif force_size == "Custom Height":
+        force_size = "?x" + str(custom_height)
+    elif force_size == "Custom Width":
+        force_size = str(custom_width) + "x?"
+
+    if force_size != "Disabled":
+        force_size = force_size.split("x")
+        if force_size[0] == "?":
+            width = (width * int(force_size[1])) // height
+            # Limit to a multple of 8 for latent conversion
+            width = int(width) + 4 & ~7
+            height = int(force_size[1])
+        elif force_size[1] == "?":
+            height = (height * int(force_size[0])) // width
+            height = int(height) + 4 & ~7
+            width = int(force_size[0])
+        else:
+            width = int(force_size[0])
+            height = int(force_size[1])
+    return (width, height)
+
+
+def cv_frame_generator(
+    video,
+    force_rate,
+    frame_load_cap,
+    skip_first_frames,
+    select_every_nth,
+    meta_batch=None,
+    unique_id=None,
+):
+    video_cap = cv2.VideoCapture(video)
+    if not video_cap.isOpened():
+        raise ValueError(f"{video} could not be loaded with cv.")
+
+    # extract video metadata
+    fps = video_cap.get(cv2.CAP_PROP_FPS)
+    width = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    duration = total_frames / fps
+
+    # set video_cap to look at start_index frame
+    total_frame_count = 0
+    total_frames_evaluated = -1
+    frames_added = 0
+    base_frame_time = 1 / fps
+    prev_frame = None
+
+    if force_rate == 0:
+        target_frame_time = base_frame_time
+    else:
+        target_frame_time = 1 / force_rate
+
+    yield (width, height, fps, duration, total_frames, target_frame_time)
+
+    time_offset = target_frame_time - base_frame_time
+    while video_cap.isOpened():
+        if time_offset < target_frame_time:
+            is_returned = video_cap.grab()
+            # if didn't return frame, video has ended
+            if not is_returned:
+                break
+            time_offset += base_frame_time
+        if time_offset < target_frame_time:
+            continue
+        time_offset -= target_frame_time
+        # if not at start_index, skip doing anything with frame
+        total_frame_count += 1
+        if total_frame_count <= skip_first_frames:
+            continue
+        else:
+            total_frames_evaluated += 1
+
+        # if should not be selected, skip doing anything with frame
+        if total_frames_evaluated % select_every_nth != 0:
+            continue
+
+        # opencv loads images in BGR format (yuck), so need to convert to RGB for ComfyUI use
+        # follow up: can videos ever have an alpha channel?
+        # To my testing: No. opencv has no support for alpha
+        unused, frame = video_cap.retrieve()
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        # convert frame to comfyui's expected format
+        # TODO: frame contains no exif information. Check if opencv2 has already applied
+        frame = np.array(frame, dtype=np.float32) / 255.0
+        if prev_frame is not None:
+            inp = yield prev_frame
+            if inp is not None:
+                # ensure the finally block is called
+                return
+        prev_frame = frame
+        frames_added += 1
+        # if cap exists and we've reached it, stop processing frames
+        if frame_load_cap > 0 and frames_added >= frame_load_cap:
+            break
+    if meta_batch is not None:
+        meta_batch.inputs.pop(unique_id)
+        meta_batch.has_closed_inputs = True
+    if prev_frame is not None:
+        yield prev_frame
+
+
+def load_video_cv(
+    video: str,
+    force_rate: int,
+    force_size: str,
+    custom_width: int,
+    custom_height: int,
+    frame_load_cap: int,
+    skip_first_frames: int,
+    select_every_nth: int,
+    meta_batch=None,
+    unique_id=None,
+):
+    if meta_batch is None or unique_id not in meta_batch.inputs:
+        gen = cv_frame_generator(
+            video,
+            force_rate,
+            frame_load_cap,
+            skip_first_frames,
+            select_every_nth,
+            meta_batch,
+            unique_id,
+        )
+        (width, height, fps, duration, total_frames, target_frame_time) = next(gen)
+
+        if meta_batch is not None:
+            meta_batch.inputs[unique_id] = (
+                gen,
+                width,
+                height,
+                fps,
+                duration,
+                total_frames,
+                target_frame_time,
+            )
+
+    else:
+        (gen, width, height, fps, duration, total_frames, target_frame_time) = (
+            meta_batch.inputs[unique_id]
+        )
+
+    if meta_batch is not None:
+        gen = itertools.islice(gen, meta_batch.frames_per_batch)
+
+    # Some minor wizardry to eliminate a copy and reduce max memory by a factor of ~2
+    images = torch.from_numpy(
+        np.fromiter(gen, np.dtype((np.float32, (height, width, 3))))
+    )
+    if len(images) == 0:
+        raise RuntimeError("No frames generated")
+    if force_size != "Disabled":
+        new_size = target_size(width, height, force_size, custom_width, custom_height)
+        if new_size[0] != width or new_size[1] != height:
+            s = images.movedim(-1, 1)
+            s = common_upscale(s, new_size[0], new_size[1], "lanczos", "center")
+            images = s.movedim(1, -1)
+
+    # Setup lambda for lazy audio capture
+    audio = lambda: get_audio(
+        video,
+        skip_first_frames * target_frame_time,
+        frame_load_cap * target_frame_time * select_every_nth,
+    )
+    # Adjust target_frame_time for select_every_nth
+    target_frame_time *= select_every_nth
+    video_info = {
+        "source_fps": fps,
+        "source_frame_count": total_frames,
+        "source_duration": duration,
+        "source_width": width,
+        "source_height": height,
+        "loaded_fps": 1 / target_frame_time,
+        "loaded_frame_count": len(images),
+        "loaded_duration": len(images) * target_frame_time,
+        "loaded_width": images.shape[2],
+        "loaded_height": images.shape[1],
+    }
+
+    return (images, len(images), lazy_eval(audio), video_info)
+
+
+class ComfyUIDeployExternalVideo:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        files = []
+        for f in os.listdir(input_dir):
+            if os.path.isfile(os.path.join(input_dir, f)):
+                file_parts = f.split(".")
+                if len(file_parts) > 1 and (file_parts[-1] in video_extensions):
+                    files.append(f)
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_video"},
+                ),
+                "force_rate": ("INT", {"default": 0, "min": 0, "max": 60, "step": 1}),
+                "force_size": (
+                    [
+                        "Disabled",
+                        "Custom Height",
+                        "Custom Width",
+                        "Custom",
+                        "256x?",
+                        "?x256",
+                        "256x256",
+                        "512x?",
+                        "?x512",
+                        "512x512",
+                    ],
+                ),
+                "custom_width": (
+                    "INT",
+                    {"default": 512, "min": 0, "max": DIMMAX, "step": 8},
+                ),
+                "custom_height": (
+                    "INT",
+                    {"default": 512, "min": 0, "max": DIMMAX, "step": 8},
+                ),
+                "frame_load_cap": (
+                    "INT",
+                    {"default": 0, "min": 0, "max": BIGMAX, "step": 1},
+                ),
+                "skip_first_frames": (
+                    "INT",
+                    {"default": 0, "min": 0, "max": BIGMAX, "step": 1},
+                ),
+                "select_every_nth": (
+                    "INT",
+                    {"default": 1, "min": 1, "max": BIGMAX, "step": 1},
+                ),
+            },
+            "optional": {
+                "meta_batch": ("VHS_BatchManager",),
+                "default_value": (sorted(files),),
+            },
+            "hidden": {"unique_id": "UNIQUE_ID"},
+        }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = (
+        "IMAGE",
+        "INT",
+        "VHS_AUDIO",
+        "VHS_VIDEOINFO",
+    )
+    RETURN_NAMES = (
+        "IMAGE",
+        "frame_count",
+        "audio",
+        "video_info",
+    )
+
+    FUNCTION = "load_video"
+
+    def load_video(self, **kwargs):
+        input_id = kwargs.get("input_id")
+        force_rate = kwargs.get("force_rate")
+        force_size = kwargs.get("force_size", "Disabled")
+        custom_width = kwargs.get("custom_width")
+        custom_height = kwargs.get("custom_height")
+        frame_load_cap = kwargs.get("frame_load_cap")
+        skip_first_frames = kwargs.get("skip_first_frames")
+        select_every_nth = kwargs.get("select_every_nth")
+        meta_batch = kwargs.get("meta_batch")
+        unique_id = kwargs.get("unique_id")
+
+        video = kwargs.get("default_value")
+        video_path = folder_paths.get_annotated_filepath(video.strip('"'))
+
+        input_dir = folder_paths.get_input_directory()
+        if input_id.startswith("http"):
+            import requests
+
+            print("Fetching video from URL: ", input_id)
+            response = requests.get(input_id, stream=True)
+            file_size = int(response.headers.get("Content-Length", 0))
+            file_extension = input_id.split(".")[-1].split("?")[
+                0
+            ]  # Extract extension and handle URLs with parameters
+            if file_extension not in video_extensions:
+                file_extension = ".mp4"
+
+            unique_filename = str(uuid.uuid4()) + "." + file_extension
+            video_path = os.path.join(input_dir, unique_filename)
+            chunk_size = 1024  # 1 Kibibyte
+
+            num_bars = int(file_size / chunk_size)
+
+            with open(video_path, "wb") as out_file:
+                for chunk in tqdm(
+                    response.iter_content(chunk_size=chunk_size),
+                    total=num_bars,
+                    unit="KB",
+                    desc="Downloading",
+                    leave=True,
+                ):
+                    out_file.write(chunk)
+
+        print("video path: ", video_path)
+
+        return load_video_cv(
+            video=video_path,
+            force_rate=force_rate,
+            force_size=force_size,
+            custom_width=custom_width,
+            custom_height=custom_height,
+            frame_load_cap=frame_load_cap,
+            skip_first_frames=skip_first_frames,
+            select_every_nth=select_every_nth,
+            meta_batch=meta_batch,
+            unique_id=unique_id,
+        )
+
+    @classmethod
+    def IS_CHANGED(s, video, **kwargs):
+        image_path = folder_paths.get_annotated_filepath(video)
+        return calculate_file_hash(image_path)
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalVideo": ComfyUIDeployExternalVideo}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalVideo": "External Video (ComfyUI Deploy x VHS)"
+}

custom_routes.py

@@ -13,53 +13,71 @@ import traceback
 import uuid
 import asyncio
 import logging
-from enum import Enum
 from urllib.parse import quote
 import threading
 import hashlib
 import aiohttp
 import aiofiles
-from typing import List, Union, Any, Optional
+from typing import Dict, List, Union, Any, Optional
 from PIL import Image
 import copy
 import struct
 
-from globals import StreamingPrompt, sockets, streaming_prompt_metadata, BaseModel
+from logging import basicConfig, getLogger
+import logfire
+# if os.environ.get('LOGFIRE_TOKEN', None) is not None:
+logfire.configure(
+    send_to_logfire="if-token-present"
+)
+# basicConfig(handlers=[logfire.LogfireLoggingHandler()])
+logfire_handler = logfire.LogfireLoggingHandler()
+logger = getLogger("comfy-deploy")
+logger.addHandler(logfire_handler)
 
-class Status(Enum):
-    NOT_STARTED = "not-started"
-    RUNNING = "running"
-    SUCCESS = "success"
-    FAILED = "failed"
-    UPLOADING = "uploading"
+from globals import StreamingPrompt, Status, sockets, SimplePrompt, streaming_prompt_metadata, prompt_metadata
 
-class SimplePrompt(BaseModel):
-    status_endpoint: str
-    file_upload_endpoint: str
-    workflow_api: dict
-    status: Status = Status.NOT_STARTED
-    progress: set = set()
-    last_updated_node: Optional[str] = None,
-    uploading_nodes: set = set()
-    done: bool = False
-    is_realtime: bool = False,
-    start_time: Optional[float] = None,
+class EventEmitter:
+    def __init__(self):
+        self.listeners = {}
+
+    def on(self, event, listener):
+        if event not in self.listeners:
+            self.listeners[event] = []
+        self.listeners[event].append(listener)
+
+    def off(self, event, listener):
+        if event in self.listeners:
+            self.listeners[event].remove(listener)
+            if not self.listeners[event]:
+                del self.listeners[event]
+
+    def emit(self, event, *args, **kwargs):
+        if event in self.listeners:
+            for listener in self.listeners[event]:
+                listener(*args, **kwargs)
+
+# Create a global event emitter instance
+event_emitter = EventEmitter()
 
 api = None
 api_task = None
-prompt_metadata: dict[str, SimplePrompt] = {}
+
 cd_enable_log = os.environ.get('CD_ENABLE_LOG', 'false').lower() == 'true'
 cd_enable_run_log = os.environ.get('CD_ENABLE_RUN_LOG', 'false').lower() == 'true'
+bypass_upload = os.environ.get('CD_BYPASS_UPLOAD', 'false').lower() == 'true'
+
+logger.info(f"CD_BYPASS_UPLOAD {bypass_upload}")
+
 
 def clear_current_prompt(sid):
     prompt_server = server.PromptServer.instance
     to_delete = list(streaming_prompt_metadata[sid].running_prompt_ids)  # Convert set to list
 
-    print("clearning out prompt: ", to_delete)
+    logger.info("clearning out prompt: ", to_delete)
     for id_to_delete in to_delete:
         delete_func = lambda a: a[1] == id_to_delete
         prompt_server.prompt_queue.delete_queue_item(delete_func)
-        print("deleted prompt: ", id_to_delete, prompt_server.prompt_queue.get_tasks_remaining())
+        logger.info("deleted prompt: ", id_to_delete, prompt_server.prompt_queue.get_tasks_remaining())
 
     streaming_prompt_metadata[sid].running_prompt_ids.clear()
 
@@ -100,7 +118,7 @@ def post_prompt(json_data):
             }
             return response
         else:
-            print("invalid prompt:", valid[1])
+            logger.info("invalid prompt:", valid[1])
             return {"error": valid[1], "node_errors": valid[3]}
     else:
         return {"error": "no prompt", "node_errors": []}
@@ -126,30 +144,26 @@ def apply_random_seed_to_workflow(workflow_api):
                 continue
             workflow_api[key]['inputs']['seed'] = randomSeed();
 
-def send_prompt(sid: str, inputs: StreamingPrompt):
-    # workflow_api = inputs.workflow_api
-    workflow_api = copy.deepcopy(inputs.workflow_api)
-    
-    # Random seed
-    apply_random_seed_to_workflow(workflow_api)
-            
-    print("getting inputs" , inputs.inputs)
-            
+def apply_inputs_to_workflow(workflow_api: Any, inputs: Any, sid: str = None):
     # Loop through each of the inputs and replace them
     for key, value in workflow_api.items():
         if 'inputs' in value:
+
+            # Support websocket
+            if sid is not None:
                 if (value["class_type"] == "ComfyDeployWebscoketImageOutput"):
                     value['inputs']["client_id"] = sid
                 if (value["class_type"] == "ComfyDeployWebscoketImageInput"):
                     value['inputs']["client_id"] = sid
 
-            if "input_id" in value['inputs'] and value['inputs']['input_id'] in inputs.inputs:
-                new_value = inputs.inputs[value['inputs']['input_id']]
+            if "input_id" in value['inputs'] and inputs is not None and value['inputs']['input_id'] in inputs:
+                new_value = inputs[value['inputs']['input_id']]
 
                 # Lets skip it if its an image
                 if isinstance(new_value, Image.Image):
                     continue
 
+                # Backward compactibility
                 value['inputs']["input_id"] = new_value
 
                 # Fix for external text default value
@@ -159,8 +173,30 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
                 if (value["class_type"] == "ComfyUIDeployExternalCheckpoint"):
                     value['inputs']["default_value"] = new_value
 
+                if (value["class_type"] == "ComfyUIDeployExternalImageBatch"):
+                    value['inputs']["images"] = new_value
 
-    print(workflow_api)
+                if value["class_type"] == "ComfyUIDeployExternalLora":
+                    value["inputs"]["default_lora_name"] = new_value
+
+                if value["class_type"] == "ComfyUIDeployExternalSlider":
+                    value["inputs"]["default_value"] = new_value
+
+                if value["class_type"] == "ComfyUIDeployExternalBoolean":
+                    value["inputs"]["default_value"] = new_value
+
+def send_prompt(sid: str, inputs: StreamingPrompt):
+    # workflow_api = inputs.workflow_api
+    workflow_api = copy.deepcopy(inputs.workflow_api)
+
+    # Random seed
+    apply_random_seed_to_workflow(workflow_api)
+
+    logger.info("getting inputs" , inputs.inputs)
+
+    apply_inputs_to_workflow(workflow_api, inputs.inputs, sid=sid)
+
+    logger.info(workflow_api)
 
     prompt_id = str(uuid.uuid4())
 
@@ -183,23 +219,22 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
         error_type = type(e).__name__
         stack_trace_short = traceback.format_exc().strip().split('\n')[-2]
         stack_trace = traceback.format_exc().strip()
-        print(f"error: {error_type}, {e}")
-        print(f"stack trace: {stack_trace_short}")
+        logger.info(f"error: {error_type}, {e}")
+        logger.info(f"stack trace: {stack_trace_short}")
 
 @server.PromptServer.instance.routes.post("/comfyui-deploy/run")
 async def comfy_deploy_run(request):
-    prompt_server = server.PromptServer.instance
     data = await request.json()
 
-    workflow_api = data.get("workflow_api")
-
+    # In older version, we use workflow_api, but this has inputs already swapped in nextjs frontend, which is tricky
+    workflow_api = data.get("workflow_api_raw")
     # The prompt id generated from comfy deploy, can be None
     prompt_id = data.get("prompt_id")
+    inputs = data.get("inputs")
 
+    # Now it handles directly in here
     apply_random_seed_to_workflow(workflow_api)
-    # for key in workflow_api:
-    #     if 'inputs' in workflow_api[key] and 'seed' in workflow_api[key]['inputs']:
-    #         workflow_api[key]['inputs']['seed'] = randomSeed()
+    apply_inputs_to_workflow(workflow_api, inputs)
 
     prompt = {
         "prompt": workflow_api,
@@ -219,8 +254,8 @@ async def comfy_deploy_run(request):
         error_type = type(e).__name__
         stack_trace_short = traceback.format_exc().strip().split('\n')[-2]
         stack_trace = traceback.format_exc().strip()
-        print(f"error: {error_type}, {e}")
-        print(f"stack trace: {stack_trace_short}")
+        logger.info(f"error: {error_type}, {e}")
+        logger.info(f"stack trace: {stack_trace_short}")
         await update_run_with_output(prompt_id, {
             "error": {
                 "error_type": error_type,
@@ -232,13 +267,6 @@ async def comfy_deploy_run(request):
         return web.Response(status=500, reason=f"{error_type}: {e}, {stack_trace_short}")
 
     status = 200
-    # if "error" in res:
-    #     status = 400
-    #     await update_run_with_output(prompt_id, {
-    #         "error": {
-    #             **res
-    #         }
-    #     })
 
     if "node_errors" in res and res["node_errors"]:
         # Even tho there are node_errors it can still be run
@@ -255,24 +283,134 @@ async def comfy_deploy_run(request):
 
     return web.json_response(res, status=status)
 
+async def stream_prompt(data):
+    # In older version, we use workflow_api, but this has inputs already swapped in nextjs frontend, which is tricky
+    workflow_api = data.get("workflow_api_raw")
+    # The prompt id generated from comfy deploy, can be None
+    prompt_id = data.get("prompt_id")
+    inputs = data.get("inputs")
+
+    # Now it handles directly in here
+    apply_random_seed_to_workflow(workflow_api)
+    apply_inputs_to_workflow(workflow_api, inputs)
+
+    prompt = {
+        "prompt": workflow_api,
+        "client_id": "comfy_deploy_instance", #api.client_id
+        "prompt_id": prompt_id
+    }
+
+    prompt_metadata[prompt_id] = SimplePrompt(
+        status_endpoint=data.get('status_endpoint'),
+        file_upload_endpoint=data.get('file_upload_endpoint'),
+        workflow_api=workflow_api
+    )
+
+    logfire.info("Begin prompt", prompt=prompt)
+
+    try:
+        res = post_prompt(prompt)
+    except Exception as e:
+        error_type = type(e).__name__
+        stack_trace_short = traceback.format_exc().strip().split('\n')[-2]
+        stack_trace = traceback.format_exc().strip()
+        logger.info(f"error: {error_type}, {e}")
+        logger.info(f"stack trace: {stack_trace_short}")
+        await update_run_with_output(prompt_id, {
+            "error": {
+                "error_type": error_type,
+                "stack_trace": stack_trace
+            }
+        })
+         # When there are critical errors, the prompt is actually not run
+        await update_run(prompt_id, Status.FAILED)
+        # return web.Response(status=500, reason=f"{error_type}: {e}, {stack_trace_short}")
+        # raise Exception("Prompt failed")
+
+    status = 200
+
+    if "node_errors" in res and res["node_errors"]:
+        # Even tho there are node_errors it can still be run
+        status = 400
+        await update_run_with_output(prompt_id, {
+            "error": {
+                **res
+            }
+        })
+
+        # When there are critical errors, the prompt is actually not run
+        if "error" in res:
+            await update_run(prompt_id, Status.FAILED)
+            # raise Exception("Prompt failed")
+
+    return res
+    # return web.json_response(res, status=status)
+
+comfy_message_queues: Dict[str, asyncio.Queue] = {}
+
+@server.PromptServer.instance.routes.post('/comfyui-deploy/run/streaming')
+async def stream_response(request):
+    response = web.StreamResponse(status=200, reason='OK', headers={'Content-Type': 'text/event-stream'})
+    await response.prepare(request)
+
+    pending = True
+    data = await request.json()
+
+    prompt_id = data.get("prompt_id")
+    comfy_message_queues[prompt_id] = asyncio.Queue()
+
+    with logfire.span('Streaming Run'):
+        logfire.info('Streaming prompt')
+
+        try:
+            result = await stream_prompt(data=data)
+            await response.write(f"event: event_update\ndata: {json.dumps(result)}\n\n".encode('utf-8'))
+            # await response.write(.encode('utf-8'))
+            await response.drain()  # Ensure the buffer is flushed
+
+            while pending:
+                if prompt_id in comfy_message_queues:
+                    if not comfy_message_queues[prompt_id].empty():
+                        data = await comfy_message_queues[prompt_id].get()
+
+                        logfire.info(data["event"], data=json.dumps(data))
+                        # logger.info("listener", data)
+                        await response.write(f"event: event_update\ndata: {json.dumps(data)}\n\n".encode('utf-8'))
+                        await response.drain()  # Ensure the buffer is flushed
+
+                        if data["event"] == "status":
+                            if data["data"]["status"] in (Status.FAILED.value, Status.SUCCESS.value):
+                                pending = False
+
+                await asyncio.sleep(0.1)  # Adjust the sleep duration as needed
+        except asyncio.CancelledError:
+            logfire.info("Streaming was cancelled")
+            raise
+        except Exception as e:
+            logfire.error("Streaming error", error=e)
+        finally:
+            # event_emitter.off("send_json", task)
+            await response.write_eof()
+            comfy_message_queues.pop(prompt_id, None)
+            return response
 
 def get_comfyui_path_from_file_path(file_path):
     file_path_parts = file_path.split("\\")
 
     if file_path_parts[0] == "input":
-        print("matching input")
+        logger.info("matching input")
         file_path = os.path.join(folder_paths.get_directory_by_type("input"), *file_path_parts[1:])
     elif file_path_parts[0] == "models":
-        print("matching models")
+        logger.info("matching models")
         file_path = folder_paths.get_full_path(file_path_parts[1], os.path.join(*file_path_parts[2:]))
 
-    print(file_path)
+    logger.info(file_path)
 
     return file_path
 
 # Form ComfyUI Manager
 async def compute_sha256_checksum(filepath):
-    print("computing sha256 checksum")
+    logger.info("computing sha256 checksum")
     chunk_size = 1024 * 256  # Example: 256KB
     filepath = get_comfyui_path_from_file_path(filepath)
     """Compute the SHA256 checksum of a file, in chunks, asynchronously"""
@@ -295,7 +433,7 @@ async def get_installed_models(request):
         file_list = folder_paths.get_filename_list(key)
         value_json_compatible = (value[0], list(value[1]), file_list)
         new_dict[key] = value_json_compatible
-    # print(new_dict)
+    # logger.info(new_dict)
     return web.json_response(new_dict)
 
 # This is start uploading the files to Comfy Deploy
@@ -305,7 +443,7 @@ async def upload_file_endpoint(request):
 
     file_path = data.get("file_path")
 
-    print("Original file path", file_path)
+    logger.info("Original file path", file_path)
 
     file_path = get_comfyui_path_from_file_path(file_path)
 
@@ -355,7 +493,7 @@ async def upload_file_endpoint(request):
                         with open(file_path, 'rb') as f:
                             headers = {
                                 "Content-Type": file_type,
-                                "x-amz-acl": "public-read",
+                                # "x-amz-acl": "public-read",
                                 "Content-Length": str(file_size)
                             }
                             async with session.put(upload_url, data=f, headers=headers) as upload_response:
@@ -382,26 +520,58 @@ async def upload_file_endpoint(request):
     }, status=500)
 
 
+script_dir = os.path.dirname(os.path.abspath(__file__))
+# Assuming the cache file is stored in the same directory as this script
+CACHE_FILE_PATH = script_dir + '/file-hash-cache.json'
+
+# Global in-memory cache
+file_hash_cache = {}
+
+# Load cache from disk at startup
+def load_cache():
+    global file_hash_cache
+    try:
+        with open(CACHE_FILE_PATH, 'r') as cache_file:
+            file_hash_cache = json.load(cache_file)
+    except (FileNotFoundError, json.JSONDecodeError):
+        file_hash_cache = {}
+
+# Save cache to disk
+def save_cache():
+    with open(CACHE_FILE_PATH, 'w') as cache_file:
+        json.dump(file_hash_cache, cache_file)
+
+# Initialize cache on application start
+load_cache()
+
 @server.PromptServer.instance.routes.get('/comfyui-deploy/get-file-hash')
 async def get_file_hash(request):
     file_path = request.rel_url.query.get('file_path', '')
 
-    if file_path is None:
+    if not file_path:
         return web.json_response({
             "error": "file_path is required"
         }, status=400)
 
     try:
         base = folder_paths.base_path
-        file_path = os.path.join(base, file_path)
-        # print("file_path", file_path)
-        start_time = time.time()  # Capture the start time
-        file_hash = await compute_sha256_checksum(
-            file_path
-        )
-        end_time = time.time()  # Capture the end time after the code execution
-        elapsed_time = end_time - start_time  # Calculate the elapsed time
-        print(f"Execution time: {elapsed_time} seconds")
+        full_file_path = os.path.join(base, file_path)
+
+        # Check if the file hash is in the cache
+        if full_file_path in file_hash_cache:
+            file_hash = file_hash_cache[full_file_path]
+        else:
+            start_time = time.time()
+            file_hash = await compute_sha256_checksum(full_file_path)
+            end_time = time.time()
+            elapsed_time = end_time - start_time
+            logger.info(f"Cache miss -> Execution time: {elapsed_time} seconds")
+
+            # Update the in-memory cache
+            file_hash_cache[full_file_path] = file_hash
+
+            save_cache()
+
         return web.json_response({
             "file_hash": file_hash
         })
@@ -415,6 +585,8 @@ async def update_realtime_run_status(realtime_id: str, status_endpoint: str, sta
         "run_id": realtime_id,
         "status": status.value,
     }
+    if (status_endpoint is None):
+        return
     # requests.post(status_endpoint, json=body)
     async with aiohttp.ClientSession() as session:
         async with session.post(status_endpoint, json=body) as response:
@@ -445,7 +617,7 @@ async def websocket_handler(request):
                 if response.status == 200:
                     workflow = await response.json()
 
-                    print("Loaded workflow version ",workflow["version"])
+                    logger.info(f"Loaded workflow version ${workflow['version']}")
 
                     streaming_prompt_metadata[sid] = StreamingPrompt(
                         workflow_api=workflow["workflow_api"],
@@ -459,7 +631,7 @@ async def websocket_handler(request):
                     # await send("workflow_api", workflow_api, sid)
                 else:
                     error_message = await response.text()
-                    print(f"Failed to fetch workflow endpoint. Status: {response.status}, Error: {error_message}")
+                    logger.info(f"Failed to fetch workflow endpoint. Status: {response.status}, Error: {error_message}")
                     # await send("error", {"message": error_message}, sid)
 
     try:
@@ -474,10 +646,10 @@ async def websocket_handler(request):
             if msg.type == aiohttp.WSMsgType.TEXT:
                 try:
                     data = json.loads(msg.data)
-                    print(data)
+                    logger.info(data)
                     event_type = data.get('event')
                     if event_type == 'input':
-                        print("Got input: ", data.get("inputs"))
+                        logger.info(f"Got input: ${data.get('inputs')}")
                         input = data.get('inputs')
                         streaming_prompt_metadata[sid].inputs.update(input)
                     elif event_type == 'queue_prompt':
@@ -487,7 +659,7 @@ async def websocket_handler(request):
                         # Handle other event types
                         pass
                 except json.JSONDecodeError:
-                    print('Failed to decode JSON from message')
+                    logger.info('Failed to decode JSON from message')
 
             if msg.type == aiohttp.WSMsgType.BINARY:
                 data = msg.data
@@ -496,9 +668,9 @@ async def websocket_handler(request):
                     image_type_code, = struct.unpack("<I", data[4:8])
                     input_id_bytes = data[8:32]  # Extract the next 24 bytes for the input ID
                     input_id = input_id_bytes.decode('ascii').strip()  # Decode the input ID from ASCII
-                    print(event_type)
-                    print(image_type_code)
-                    print(input_id)
+                    logger.info(event_type)
+                    logger.info(image_type_code)
+                    logger.info(input_id)
                     image_data = data[32:]  # The rest is the image data
                     if image_type_code == 1:
                         image_type = "JPEG"
@@ -507,7 +679,7 @@ async def websocket_handler(request):
                     elif image_type_code == 3:
                         image_type = "WEBP"
                     else:
-                        print("Unknown image type code:", image_type_code)
+                        logger.info(f"Unknown image type code: ${image_type_code}")
                         return
                     image = Image.open(BytesIO(image_data))
                     # Check if the input ID already exists and replace the input with the new one
@@ -518,14 +690,14 @@ async def websocket_handler(request):
                             if hasattr(existing_image, 'close'):
                                 existing_image.close()
                         except Exception as e:
-                            print(f"Error closing previous image for input ID {input_id}: {e}")
+                            logger.info(f"Error closing previous image for input ID {input_id}: {e}")
                     streaming_prompt_metadata[sid].inputs[input_id] = image
                     # clear_current_prompt(sid)
                     # send_prompt(sid, streaming_prompt_metadata[sid])
-                    print(f"Received {image_type} image of size {image.size} with input ID {input_id}")
+                    logger.info(f"Received {image_type} image of size {image.size} with input ID {input_id}")
 
             if msg.type == aiohttp.WSMsgType.ERROR:
-                print('ws connection closed with exception %s' % ws.exception())
+                logger.info('ws connection closed with exception %s' % ws.exception())
     finally:
         sockets.pop(sid, None)
 
@@ -570,16 +742,16 @@ async def send(event, data, sid=None):
                 if not ws.closed:  # Check if the WebSocket connection is open and not closing
                     await ws.send_json({ 'event': event, 'data': data })
     except Exception as e:
-        print(f"Exception: {e}")
+        logger.info(f"Exception: {e}")
         traceback.print_exc()
 
-logging.basicConfig(level=logging.INFO)
+
 
 prompt_server = server.PromptServer.instance
 send_json = prompt_server.send_json
 
 async def send_json_override(self, event, data, sid=None):
-    # print("INTERNAL:", event, data, sid)
+    # logger.info("INTERNAL:", event, data, sid)
     prompt_id = data.get('prompt_id')
 
     target_sid = sid
@@ -592,8 +764,19 @@ async def send_json_override(self, event, data, sid=None):
         asyncio.create_task(self.send_json_original(event, data, sid))
     ])
 
+    if prompt_id in comfy_message_queues:
+        comfy_message_queues[prompt_id].put_nowait({
+            "event": event,
+            "data": data
+        })
+
+    # event_emitter.emit("send_json", {
+    #     "event": event,
+    #     "data": data
+    # })
+
     if event == 'execution_start':
-        update_run(prompt_id, Status.RUNNING)
+        await update_run(prompt_id, Status.RUNNING)
 
         if prompt_id in prompt_metadata:
             prompt_metadata[prompt_id].start_time = time.perf_counter()
@@ -602,12 +785,12 @@ async def send_json_override(self, event, data, sid=None):
     if event == 'executing' and data.get('node') is None:
         mark_prompt_done(prompt_id=prompt_id)
         if not have_pending_upload(prompt_id):
-            update_run(prompt_id, Status.SUCCESS)
+            await update_run(prompt_id, Status.SUCCESS)
             if prompt_id in prompt_metadata:
                 current_time = time.perf_counter()
                 if prompt_metadata[prompt_id].start_time is not None:
                     elapsed_time = current_time - prompt_metadata[prompt_id].start_time
-                    print(f"Elapsed time: {elapsed_time} seconds")
+                    logger.info(f"Elapsed time: {elapsed_time} seconds")
                     await send("elapsed_time", {
                         "prompt_id": prompt_id,
                         "elapsed_time": elapsed_time
@@ -622,13 +805,13 @@ async def send_json_override(self, event, data, sid=None):
 
             prompt_metadata[prompt_id].progress.add(node)
             calculated_progress = len(prompt_metadata[prompt_id].progress) / len(prompt_metadata[prompt_id].workflow_api)
-            # print("calculated_progress", calculated_progress)
+            # logger.info("calculated_progress", calculated_progress)
 
             if prompt_metadata[prompt_id].last_updated_node is not None and prompt_metadata[prompt_id].last_updated_node == node:
                 return
             prompt_metadata[prompt_id].last_updated_node = node
             class_type = prompt_metadata[prompt_id].workflow_api[node]['class_type']
-            print("updating run live status", class_type)
+            logger.info(f"updating run live status {class_type}")
             await send("live_status", {
                 "prompt_id": prompt_id,
                 "current_node": class_type,
@@ -649,10 +832,19 @@ async def send_json_override(self, event, data, sid=None):
     if event == 'execution_error':
         # Careful this might not be fully awaited.
         await update_run_with_output(prompt_id, data)
-        update_run(prompt_id, Status.FAILED)
+        await update_run(prompt_id, Status.FAILED)
         # await update_run_with_output(prompt_id, data)
 
     if event == 'executed' and 'node' in data and 'output' in data:
+        logger.info(f"executed {data}")
+        if prompt_id in prompt_metadata:
+            node = data.get('node')
+            class_type = prompt_metadata[prompt_id].workflow_api[node]['class_type']
+            logger.info(f"executed {class_type}")
+            if class_type == "PreviewImage":
+                logger.info("skipping preview image")
+                return
+
         await update_run_with_output(prompt_id, data.get('output'), node_id=data.get('node'))
         # await update_run_with_output(prompt_id, data.get('output'), node_id=data.get('node'))
         # update_run_with_output(prompt_id, data.get('output'))
@@ -667,21 +859,36 @@ async def update_run_live_status(prompt_id, live_status, calculated_progress: fl
     if prompt_metadata[prompt_id].is_realtime is True:
         return
 
-    print("progress", calculated_progress)
-    
     status_endpoint = prompt_metadata[prompt_id].status_endpoint
+
+    if (status_endpoint is None):
+        return
+
+    logger.info(f"progress {calculated_progress}")
+
     body = {
         "run_id": prompt_id,
         "live_status": live_status,
         "progress": calculated_progress
     }
+
+    if prompt_id in comfy_message_queues:
+        comfy_message_queues[prompt_id].put_nowait({
+            "event": "live_status",
+            "data": {
+                "prompt_id": prompt_id,
+                "live_status": live_status,
+                "progress": calculated_progress
+            }
+        })
+
     # requests.post(status_endpoint, json=body)
     async with aiohttp.ClientSession() as session:
         async with session.post(status_endpoint, json=body) as response:
             pass
 
 
-def update_run(prompt_id: str, status: Status):
+async def update_run(prompt_id: str, status: Status):
     global last_read_line_number
 
     if prompt_id not in prompt_metadata:
@@ -696,7 +903,7 @@ def update_run(prompt_id: str, status: Status):
     if (prompt_metadata[prompt_id].status != status):
 
         # when the status is already failed, we don't want to update it to success
-        if ('status' in prompt_metadata[prompt_id] and prompt_metadata[prompt_id].status == Status.FAILED):
+        if (prompt_metadata[prompt_id].status is Status.FAILED):
             return
 
         status_endpoint = prompt_metadata[prompt_id].status_endpoint
@@ -704,18 +911,22 @@ def update_run(prompt_id: str, status: Status):
             "run_id": prompt_id,
             "status": status.value,
         }
-        print(f"Status: {status.value}")
+        logger.info(f"Status: {status.value}")
 
         try:
-            requests.post(status_endpoint, json=body)
+            # requests.post(status_endpoint, json=body)
+            if (status_endpoint is not None):
+                async with aiohttp.ClientSession() as session:
+                    async with session.post(status_endpoint, json=body) as response:
+                        pass
 
-            if cd_enable_run_log and (status == Status.SUCCESS or status == Status.FAILED):
+            if (status_endpoint is not None) and cd_enable_run_log and (status == Status.SUCCESS or status == Status.FAILED):
                 try:
                     with open(comfyui_file_path, 'r') as log_file:
                         # log_data = log_file.read()
                         # Move to the last read line
                         all_log_data = log_file.read()  # Read all log data
-                        print("All log data before skipping:", all_log_data)  # Log all data before skipping
+                        # logger.info("All log data before skipping: ")  # Log all data before skipping
                         log_file.seek(0)  # Reset file pointer to the beginning
 
                         for _ in range(last_read_line_number):
@@ -723,9 +934,9 @@ def update_run(prompt_id: str, status: Status):
                         log_data = log_file.read()
                         # Update the last read line number
                         last_read_line_number += log_data.count('\n')
-                        print("last_read_line_number", last_read_line_number)
-                        print("log_data", log_data)
-                        print("log_data.count(n)", log_data.count('\n'))
+                        # logger.info("last_read_line_number", last_read_line_number)
+                        # logger.info("log_data", log_data)
+                        # logger.info("log_data.count(n)", log_data.count('\n'))
 
                         body = {
                             "run_id": prompt_id,
@@ -736,16 +947,28 @@ def update_run(prompt_id: str, status: Status):
                                 }
                             ]
                         }
-                        requests.post(status_endpoint, json=body)
+
+                        async with aiohttp.ClientSession() as session:
+                            async with session.post(status_endpoint, json=body) as response:
+                                pass
+                        # requests.post(status_endpoint, json=body)
                 except Exception as log_error:
-                    print(f"Error reading log file: {log_error}")
+                    logger.info(f"Error reading log file: {log_error}")
 
         except Exception as e:
             error_type = type(e).__name__
             stack_trace = traceback.format_exc().strip()
-            print(f"Error occurred while updating run: {e} {stack_trace}")
+            logger.info(f"Error occurred while updating run: {e} {stack_trace}")
         finally:
             prompt_metadata[prompt_id].status = status
+            if prompt_id in comfy_message_queues:
+                comfy_message_queues[prompt_id].put_nowait({
+                    "event": "status",
+                    "data": {
+                        "prompt_id": prompt_id,
+                        "status": status.value,
+                    }
+                })
 
 
 async def upload_file(prompt_id, filename, subfolder=None, content_type="image/png", type="output"):
@@ -763,7 +986,7 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
         output_dir = folder_paths.get_directory_by_type(type)
 
     if output_dir is None:
-        print(filename, "Upload failed: output_dir is None")
+        logger.info(f"{filename} Upload failed: output_dir is None")
         return
 
     if subfolder != None:
@@ -775,7 +998,7 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
     filename = os.path.basename(filename)
     file = os.path.join(output_dir, filename)
 
-    print("uploading file", file)
+    logger.info(f"uploading file {file}")
 
     file_upload_endpoint = prompt_metadata[prompt_id].file_upload_endpoint
 
@@ -785,27 +1008,34 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
 
     target_url = f"{file_upload_endpoint}?file_name={filename}&run_id={prompt_id}&type={content_type}"
 
+    start_time = time.time()  # Start timing here
     result = requests.get(target_url)
+    end_time = time.time()  # End timing after the request is complete
+    logger.info("Time taken for getting file upload endpoint: {:.2f} seconds".format(end_time - start_time))
     ok = result.json()
 
+    start_time = time.time()  # Start timing here
+
     with open(file, 'rb') as f:
         data = f.read()
         headers = {
-            "x-amz-acl": "public-read",
+            # "x-amz-acl": "public-read",
             "Content-Type": content_type,
             "Content-Length": str(len(data)),
         }
-        response = requests.put(ok.get("url"), headers=headers, data=data)
+        # response = requests.put(ok.get("url"), headers=headers, data=data)
         async with aiohttp.ClientSession() as session:
             async with session.put(ok.get("url"), headers=headers, data=data) as response:
-                print("upload file response", response.status)
+                logger.info(f"Upload file response status: {response.status}, status text: {response.reason}")
+                end_time = time.time()  # End timing after the request is complete
+                logger.info("Upload time: {:.2f} seconds".format(end_time - start_time))
 
 def have_pending_upload(prompt_id):
     if prompt_id in prompt_metadata and len(prompt_metadata[prompt_id].uploading_nodes) > 0:
-        print("have pending upload ", len(prompt_metadata[prompt_id].uploading_nodes))
+        logger.info(f"have pending upload {len(prompt_metadata[prompt_id].uploading_nodes)}")
         return True
 
-    print("no pending upload")
+    logger.info("no pending upload")
     return False
 
 def mark_prompt_done(prompt_id):
@@ -817,7 +1047,7 @@ def mark_prompt_done(prompt_id):
     """
     if prompt_id in prompt_metadata:
         prompt_metadata[prompt_id].done = True
-        print("Prompt done")
+        logger.info("Prompt done")
 
 def is_prompt_done(prompt_id: str):
     """
@@ -849,8 +1079,8 @@ async def handle_error(prompt_id, data, e: Exception):
         }
     }
     await update_file_status(prompt_id, data, False, have_error=True)
-    print(body)
-    print(f"Error occurred while uploading file: {e}")
+    logger.info(body)
+    logger.info(f"Error occurred while uploading file: {e}")
 
 # Mark the current prompt requires upload, and block it from being marked as success
 async def update_file_status(prompt_id: str, data, uploading, have_error=False, node_id=None):
@@ -863,11 +1093,11 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
         else:
             prompt_metadata[prompt_id].uploading_nodes.discard(node_id)
 
-    print(prompt_metadata[prompt_id].uploading_nodes)
+    logger.info(prompt_metadata[prompt_id].uploading_nodes)
     # Update the remote status
 
     if have_error:
-        update_run(prompt_id, Status.FAILED)
+        await update_run(prompt_id, Status.FAILED)
         await send("failed", {
             "prompt_id": prompt_id,
         })
@@ -876,15 +1106,15 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
     # if there are still nodes that are uploading, then we set the status to uploading
     if uploading:
         if prompt_metadata[prompt_id].status != Status.UPLOADING:
-            update_run(prompt_id, Status.UPLOADING)
+            await update_run(prompt_id, Status.UPLOADING)
             await send("uploading", {
                 "prompt_id": prompt_id,
             })
 
     # if there are no nodes that are uploading, then we set the status to success
     elif not uploading and not have_pending_upload(prompt_id) and is_prompt_done(prompt_id=prompt_id):
-        update_run(prompt_id, Status.SUCCESS)
-        print("Status: SUCCUSS")
+        await update_run(prompt_id, Status.SUCCESS)
+        # logger.info("Status: SUCCUSS")
         await send("success", {
             "prompt_id": prompt_id,
         })
@@ -892,15 +1122,27 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
 async def handle_upload(prompt_id: str, data, key: str, content_type_key: str, default_content_type: str):
     items = data.get(key, [])
     for item in items:
+        # # Skipping temp files
+        if item.get("type") == "temp":
+            continue
+
+        file_type = item.get(content_type_key, default_content_type)
+        file_extension = os.path.splitext(item.get("filename"))[1]
+        if file_extension in ['.jpg', '.jpeg']:
+            file_type = 'image/jpeg'
+        elif file_extension == '.png':
+            file_type = 'image/png'
+        elif file_extension == '.webp':
+            file_type = 'image/webp'
+
         await upload_file(
             prompt_id,
             item.get("filename"),
             subfolder=item.get("subfolder"),
             type=item.get("type"),
-            content_type=item.get(content_type_key, default_content_type)
+            content_type=file_type
         )
 
-
 # Upload files in the background
 async def upload_in_background(prompt_id: str, data, node_id=None, have_upload=True):
     try:
@@ -908,6 +1150,7 @@ async def upload_in_background(prompt_id: str, data, node_id=None, have_upload=T
         await handle_upload(prompt_id, data, 'files', "content_type", "image/png")
         # This will also be mp4
         await handle_upload(prompt_id, data, 'gifs', "format", "image/gif")
+        await handle_upload(prompt_id, data, 'mesh', "format", "application/octet-stream")
 
         if have_upload:
             await update_file_status(prompt_id, data, False, node_id=node_id)
@@ -927,21 +1170,29 @@ async def update_run_with_output(prompt_id, data, node_id=None):
         "run_id": prompt_id,
         "output_data": data
     }
+    have_upload_media = 'images' in data or 'files' in data or 'gifs' in data or 'mesh' in data
+    if bypass_upload and have_upload_media:
+        print("CD_BYPASS_UPLOAD is enabled, skipping the upload of the output:", node_id)
+        return
 
+    if have_upload_media:
         try:
-        have_upload = 'images' in data or 'files' in data or 'gifs' in data
-        print("\nhave_upload", have_upload, node_id)
+            logger.info(f"\nhave_upload {have_upload} {node_id}")
 
-        if have_upload:
+            if have_upload_media:
                 await update_file_status(prompt_id, data, True, node_id=node_id)
 
-        asyncio.create_task(upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload))
+            asyncio.create_task(upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload_media))
+            # await upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload)
 
         except Exception as e:
             await handle_error(prompt_id, data, e)
 
-
-    requests.post(status_endpoint, json=body)
+    # requests.post(status_endpoint, json=body)
+    if status_endpoint is not None:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(status_endpoint, json=body) as response:
+                pass
 
     await send('outputs_uploaded', {
         "prompt_id": prompt_id
@@ -995,3 +1246,9 @@ def run_in_new_thread(coroutine):
 
 if cd_enable_log:
     run_in_new_thread(watch_file_changes(log_file_path, send_logs_to_websocket))
+
+# use after calling GET /object_info (it populates the `filename_list_cache` variable)
+@server.PromptServer.instance.routes.get("/comfyui-deploy/filename_list_cache")
+async def get_filename_list_cache(_):
+    from folder_paths import filename_list_cache
+    return web.json_response({'filename_list': filename_list_cache})

globals.py

@@ -1,26 +1,45 @@
 import struct
-
+from enum import Enum
 import aiohttp
-
 from typing import List, Union, Any, Optional
 from PIL import Image, ImageOps
 from io import BytesIO
-
 from pydantic import BaseModel as PydanticBaseModel
 
 class BaseModel(PydanticBaseModel):
     class Config:
         arbitrary_types_allowed = True
         
+class Status(Enum):
+    NOT_STARTED = "not-started"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    UPLOADING = "uploading"
+
 class StreamingPrompt(BaseModel):
     workflow_api: Any
     auth_token: str
     inputs: dict[str, Union[str, bytes, Image.Image]]
     running_prompt_ids: set[str] = set()
-    status_endpoint: str
-    file_upload_endpoint: str
+    status_endpoint: Optional[str]
+    file_upload_endpoint: Optional[str]
+    
+class SimplePrompt(BaseModel):
+    status_endpoint: Optional[str]
+    file_upload_endpoint: Optional[str]
+    
+    workflow_api: dict
+    status: Status = Status.NOT_STARTED
+    progress: set = set()
+    last_updated_node: Optional[str] = None,
+    uploading_nodes: set = set()
+    done: bool = False
+    is_realtime: bool = False,
+    start_time: Optional[float] = None,
 
 sockets = dict()
+prompt_metadata: dict[str, SimplePrompt] = {}
 streaming_prompt_metadata: dict[str, StreamingPrompt] = {}
 
 class BinaryEventTypes:

prestartup_script.py

@@ -58,6 +58,9 @@ if cd_enable_log:
    print("** Comfy Deploy logging enabled")
    setup() 
 
+
+# Store the original working directory
+original_cwd = os.getcwd()
 try:
     # Get the absolute path of the script's directory
     script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -67,3 +70,6 @@ try:
     print(f"** Comfy Deploy Revision: {current_git_commit}")
 except Exception as e:
     print(f"** Comfy Deploy failed to get current git commit: {str(e)}")
+finally:
+    # Change back to the original directory
+    os.chdir(original_cwd)

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "comfyui-deploy"
+description = "Open source comfyui deployment platform, a vercel for generative workflow infra."
+version = "1.0.0"
+license = "LICENSE"
+dependencies = ["aiofiles", "pydantic", "opencv-python", "imageio-ffmpeg"]
+
+[project.urls]
+Repository = "https://github.com/BennyKok/comfyui-deploy"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "comfydeploy"
+DisplayName = "comfyui-deploy"
+Icon = ""

requirements.txt

@@ -1,2 +1,5 @@
 aiofiles
 pydantic
+opencv-python
+imageio-ffmpeg
+logfire

web-plugin/index.js

@@ -1,10 +1,90 @@
 import { app } from "./app.js";
 import { api } from "./api.js";
 import { ComfyWidgets, LGraphNode } from "./widgets.js";
-import { generateDependencyGraph } from "https://esm.sh/[email protected]2";
+import { generateDependencyGraph } from "https://esm.sh/[email protected]5";
 
 const loadingIcon = `<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><g fill="none" stroke="#888888" stroke-linecap="round" stroke-width="2"><path stroke-dasharray="60" stroke-dashoffset="60" stroke-opacity=".3" d="M12 3C16.9706 3 21 7.02944 21 12C21 16.9706 16.9706 21 12 21C7.02944 21 3 16.9706 3 12C3 7.02944 7.02944 3 12 3Z"><animate fill="freeze" attributeName="stroke-dashoffset" dur="1.3s" values="60;0"/></path><path stroke-dasharray="15" stroke-dashoffset="15" d="M12 3C16.9706 3 21 7.02944 21 12"><animate fill="freeze" attributeName="stroke-dashoffset" dur="0.3s" values="15;0"/><animateTransform attributeName="transform" dur="1.5s" repeatCount="indefinite" type="rotate" values="0 12 12;360 12 12"/></path></g></svg>`;
 
+function sendEventToCD(event, data) {
+  const message = {
+    type: event,
+    data: data,
+  };
+  window.parent.postMessage(JSON.stringify(message), "*");
+}
+
+function dispatchAPIEventData(data) {
+  const msg = JSON.parse(data);
+
+  // Custom parse error
+  if (msg.error) {
+    let message = msg.error.message;
+    if (msg.error.details)
+      message += ": " + msg.error.details;
+    for (const [nodeID, nodeError] of Object.entries(
+      msg.node_errors,
+    )) {
+      message += "\n" + nodeError.class_type + ":";
+      for (const errorReason of nodeError.errors) {
+        message +=
+          "\n    - " + errorReason.message + ": " + errorReason.details;
+      }
+    }
+
+    app.ui.dialog.show(message);
+    if (msg.node_errors) {
+      app.lastNodeErrors = msg.node_errors;
+      app.canvas.draw(true, true);
+    }
+  }
+
+  switch (msg.event) {
+    case "error":
+      break;
+    case "status":
+      if (msg.data.sid) {
+        // this.clientId = msg.data.sid;
+        // window.name = this.clientId; // use window name so it isnt reused when duplicating tabs
+        // sessionStorage.setItem("clientId", this.clientId); // store in session storage so duplicate tab can load correct workflow
+      }
+      api.dispatchEvent(new CustomEvent("status", { detail: msg.data.status }));
+      break;
+    case "progress":
+      api.dispatchEvent(new CustomEvent("progress", { detail: msg.data }));
+      break;
+    case "executing":
+      api.dispatchEvent(
+        new CustomEvent("executing", { detail: msg.data.node }),
+      );
+      break;
+    case "executed":
+      api.dispatchEvent(new CustomEvent("executed", { detail: msg.data }));
+      break;
+    case "execution_start":
+      api.dispatchEvent(
+        new CustomEvent("execution_start", { detail: msg.data }),
+      );
+      break;
+    case "execution_error":
+      api.dispatchEvent(
+        new CustomEvent("execution_error", { detail: msg.data }),
+      );
+      break;
+    case "execution_cached":
+      api.dispatchEvent(
+        new CustomEvent("execution_cached", { detail: msg.data }),
+      );
+      break;
+    default:
+      api.dispatchEvent(new CustomEvent(msg.type, { detail: msg.data }));
+    // default:
+    // if (this.#registered.has(msg.type)) {
+    // } else {
+    // throw new Error(`Unknown message type ${msg.type}`);
+    // }
+  }
+}
+
 /** @typedef {import('../../../web/types/comfy.js').ComfyExtension} ComfyExtension*/
 /** @type {ComfyExtension} */
 const ext = {
@@ -18,6 +98,34 @@ const ext = {
     const auth_token = queryParams.get("auth_token");
     const org_display = queryParams.get("org_display");
     const origin = queryParams.get("origin");
+    const workspace_mode = queryParams.get("workspace_mode");
+
+    if (workspace_mode) {
+      document.querySelector(".comfy-menu").style.display = "none";
+
+      sendEventToCD("cd_plugin_onInit");
+
+      app.queuePrompt = ((originalFunction) => async () => {
+        // const prompt = await app.graphToPrompt();
+        sendEventToCD("cd_plugin_onQueuePromptTrigger");
+      })(app.queuePrompt);
+
+      // // Intercept the onkeydown event
+      // window.addEventListener(
+      //   "keydown",
+      //   (event) => {
+      //     // Check for specific keys if necessary
+      //     console.log("hi");
+      //     if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
+      //       event.preventDefault();
+      //       event.stopImmediatePropagation();
+      //       event.stopPropagation();
+      //       sendEventToCD("cd_plugin_onQueuePrompt", prompt);
+      //     }
+      //   },
+      //   true,
+      // );
+    }
 
     const data = getData();
     let endpoint = data.endpoint;
@@ -152,9 +260,37 @@ const ext = {
   async setup() {
     // const graphCanvas = document.getElementById("graph-canvas");
 
-    window.addEventListener("message", (event) => {
-      if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
-        return;
+    window.addEventListener("message", async (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        if (message.type === "graph_load") {
+          const comfyUIWorkflow = message.data;
+          console.log("recieved: ", comfyUIWorkflow);
+          // Assuming there's a method to load the workflow data into the ComfyUI
+          // This part of the code would depend on how the ComfyUI expects to receive and process the workflow data
+          // For demonstration, let's assume there's a loadWorkflow method in the ComfyUI API
+          if (comfyUIWorkflow && app && app.loadGraphData) {
+            app.loadGraphData(comfyUIWorkflow);
+          }
+        } else if (message.type === "deploy") {
+          // deployWorkflow();
+          const prompt = await app.graphToPrompt();
+          sendEventToCD("cd_plugin_onDeployChanges", prompt);
+        } else if (message.type === "queue_prompt") {
+          const prompt = await app.graphToPrompt();
+          sendEventToCD("cd_plugin_onQueuePrompt", prompt);
+        } else if (message.type === "event") {
+          dispatchAPIEventData(message.data);
+        }
+        // else if (message.type === "refresh") {
+        //   sendEventToCD("cd_plugin_onRefresh");
+        // }
+      } catch (error) {
+        // console.error("Error processing message:", error);
+      }
+
+      // if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
+      //   return;
       //   updateBlendshapesPrompts(event.data.flow);
     });
 
@@ -167,6 +303,18 @@ const ext = {
 
       //   }
     });
+
+    app.graph.onAfterChange = ((originalFunction) =>
+      async function () {
+        const prompt = await app.graphToPrompt();
+        sendEventToCD("cd_plugin_onAfterChange", prompt);
+
+        if (typeof originalFunction === "function") {
+          originalFunction.apply(this, arguments);
+        }
+      })(app.graph.onAfterChange);
+
+    sendEventToCD("cd_plugin_setup");
   },
 };
 
@@ -267,14 +415,9 @@ function createDynamicUIHtml(data) {
   return html;
 }
 
-function addButton() {
-  const menu = document.querySelector(".comfy-menu");
+async function deployWorkflow() {
+  const deploy = document.getElementById("deploy-button");
 
-  const deploy = document.createElement("button");
-  deploy.style.position = "relative";
-  deploy.style.display = "block";
-  deploy.innerHTML = "<div id='button-title'>Deploy</div>";
-  deploy.onclick = async () => {
   /** @type {LGraph} */
   const graph = app.graph;
 
@@ -412,9 +555,7 @@ function addButton() {
         console.log(file);
         loadingDialog.showLoading("Generating hash", file);
         const hash = await fetch(
-            `/comfyui-deploy/get-file-hash?file_path=${encodeURIComponent(
-              file,
-            )}`,
+          `/comfyui-deploy/get-file-hash?file_path=${encodeURIComponent(file)}`,
         ).then((x) => x.json());
         loadingDialog.showLoading("Generating hash", file);
         console.log(hash);
@@ -424,17 +565,14 @@ function addButton() {
         console.log("Uploading ", file);
         loadingDialog.showLoading("Uploading file", file);
         try {
-            const { download_url } = await fetch(
-              `/comfyui-deploy/upload-file`,
-              {
+          const { download_url } = await fetch(`/comfyui-deploy/upload-file`, {
             method: "POST",
             body: JSON.stringify({
               file_path: file,
               token: apiKey,
               url: endpoint + "/api/upload-url",
             }),
-              },
-            )
+          })
             .then((x) => x.json())
             .catch(() => {
               loadingDialog.close();
@@ -555,6 +693,18 @@ function addButton() {
       title.style.color = "white";
     }, 1000);
   }
+}
+
+function addButton() {
+  const menu = document.querySelector(".comfy-menu");
+
+  const deploy = document.createElement("button");
+  deploy.id = "deploy-button";
+  deploy.style.position = "relative";
+  deploy.style.display = "block";
+  deploy.innerHTML = "<div id='button-title'>Deploy</div>";
+  deploy.onclick = async () => {
+    await deployWorkflow();
   };
 
   const config = document.createElement("img");