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_lora.py

@@ -16,8 +16,8 @@ class ComfyUIDeployExternalLora:
                 ),
             },
             "optional": {
-                "default_lora_name": (folder_paths.get_filename_list("loras"), ),
-            }
+                "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

@@ -30,6 +30,10 @@ api_task = None
 
 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'
+
+print("CD_BYPASS_UPLOAD", bypass_upload)
+
 
 def clear_current_prompt(sid):
     prompt_server = server.PromptServer.instance
@@ -118,7 +122,7 @@ def apply_inputs_to_workflow(workflow_api: Any, inputs: Any, sid: str = None):
                 if (value["class_type"] == "ComfyDeployWebscoketImageInput"):
                     value['inputs']["client_id"] = sid
                     
-            if "input_id" in value['inputs'] and value['inputs']['input_id'] in inputs:
+            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
@@ -137,6 +141,15 @@ def apply_inputs_to_workflow(workflow_api: Any, inputs: Any, sid: str = None):
                     
                 if (value["class_type"] == "ComfyUIDeployExternalImageBatch"):
                     value['inputs']["images"] = new_value
+                
+                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
@@ -344,7 +357,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:
@@ -815,20 +828,27 @@ 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
+    print("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)
+                print("Upload file response", response.status)
+                end_time = time.time()  # End timing after the request is complete
+                print("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:
@@ -914,7 +934,7 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
     # 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")
+        # print("Status: SUCCUSS")
         await send("success", {
             "prompt_id": prompt_id,
         })
@@ -925,12 +945,22 @@ async def handle_upload(prompt_id: str, data, key: str, content_type_key: str, d
         # # 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
@@ -940,6 +970,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)
@@ -959,19 +990,23 @@ 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
 
-    try:
-        have_upload = 'images' in data or 'files' in data or 'gifs' in data
-        print("\nhave_upload", have_upload, node_id)
+    if have_upload_media:
+        try:
+            print("\nhave_upload", have_upload_media, node_id)
 
-        if have_upload:
-            await update_file_status(prompt_id, data, True, node_id=node_id)
+            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)
-        
+        except Exception as e:
+            await handle_error(prompt_id, data, e)
 
     requests.post(status_endpoint, json=body)
 
@@ -1027,3 +1062,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})

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,4 @@
 aiofiles
-pydantic
+pydantic
+opencv-python
+imageio-ffmpeg

web-plugin/index.js

@@ -30,6 +30,30 @@ const ext = {
 
     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();
@@ -204,7 +228,8 @@ const ext = {
       //   }
     });
 
-    app.graph.onAfterChange = ((originalFunction) => async function () {
+    app.graph.onAfterChange = ((originalFunction) =>
+      async function () {
         const prompt = await app.graphToPrompt();
         sendEventToCD("cd_plugin_onAfterChange", prompt);
 
@@ -454,9 +479,7 @@ async function deployWorkflow() {
         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);
@@ -466,17 +489,14 @@ async function deployWorkflow() {
         console.log("Uploading ", file);
         loadingDialog.showLoading("Uploading file", file);
         try {
-          const { download_url } = await fetch(
-            `/comfyui-deploy/upload-file`,
-            {
-              method: "POST",
-              body: JSON.stringify({
-                file_path: file,
-                token: apiKey,
-                url: endpoint + "/api/upload-url",
-              }),
-            },
-          )
+          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();
@@ -608,7 +628,7 @@ function addButton() {
   deploy.style.display = "block";
   deploy.innerHTML = "<div id='button-title'>Deploy</div>";
   deploy.onclick = async () => {
-    await deployWorkflow()
+    await deployWorkflow();
   };
 
   const config = document.createElement("img");