Merge branch 'main' into nickkao/gpu_event

This reverts commit 5a78ca97bd.

comfy-nodes/external_boolean.py

@@ -8,6 +8,16 @@ class ComfyUIDeployExternalBoolean:
                     {"multiline": False, "default": "input_bool"},
                 ),
                 "default_value": ("BOOLEAN", {"default": False})
+            },
+            "optional": {
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
             }
         }
 
@@ -16,7 +26,7 @@ class ComfyUIDeployExternalBoolean:
     
     FUNCTION = "run"
     
-    def run(self, input_id, default_value=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None):
         print(f"Node '{input_id}' processing with switch set to {default_value}")
         return [default_value]
     

comfy-nodes/external_checkpoints.py

@@ -5,6 +5,12 @@ import torch
 import folder_paths
 from tqdm import tqdm
 
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+        
+WILDCARD = AnyType("*")
+
 class ComfyUIDeployExternalCheckpoint:
     @classmethod
     def INPUT_TYPES(s):
@@ -17,17 +23,25 @@ class ComfyUIDeployExternalCheckpoint:
             },
             "optional": {
                 "default_value": (folder_paths.get_filename_list("checkpoints"), ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
             }
         }
 
-    RETURN_TYPES = (folder_paths.get_filename_list("checkpoints"),)
+    RETURN_TYPES = (WILDCARD,)
     RETURN_NAMES = ("path",)
 
     FUNCTION = "run"
 
     CATEGORY = "deploy"
 
-    def run(self, input_id, default_value=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None):
         import requests
         import os
         import uuid

comfy-nodes/external_face_model.py

@@ -0,0 +1,108 @@
+from PIL import Image, ImageOps
+import numpy as np
+import torch
+import folder_paths
+
+
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+WILDCARD = AnyType("*")
+
+
+class ComfyUIDeployExternalFaceModel:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_reactor_face_model"},
+                ),
+            },
+            "optional": {
+                "default_face_model_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "face_model_save_name": (  # if `default_face_model_name` is a link to download a file, we will attempt to save it with this name
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+                "face_model_url": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+            },
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("path",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "deploy"
+
+    def run(
+        self,
+        input_id,
+        default_face_model_name=None,
+        face_model_save_name=None,
+        display_name=None,
+        description=None,
+        face_model_url=None,
+    ):
+        import requests
+        import os
+        import uuid
+
+        if face_model_url and face_model_url.startswith("http"):
+            if face_model_save_name:
+                existing_face_models = folder_paths.get_filename_list("reactor/faces")
+                # Check if face_model_save_name exists in the list
+                if face_model_save_name in existing_face_models:
+                    print(f"using face model: {face_model_save_name}")
+                    return (face_model_save_name,)
+            else:
+                face_model_save_name = str(uuid.uuid4()) + ".safetensors"
+            print(face_model_save_name)
+            print(folder_paths.folder_names_and_paths["reactor/faces"][0][0])
+            destination_path = os.path.join(
+                folder_paths.folder_names_and_paths["reactor/faces"][0][0],
+                face_model_save_name,
+            )
+
+            print(destination_path)
+            print(
+                "Downloading external face model - "
+                + face_model_url
+                + " to "
+                + destination_path
+            )
+            response = requests.get(
+                face_model_url,
+                headers={"User-Agent": "Mozilla/5.0"},
+                allow_redirects=True,
+            )
+            with open(destination_path, "wb") as out_file:
+                out_file.write(response.content)
+            return (face_model_save_name,)
+        else:
+            print(f"using face model: {default_face_model_name}")
+            return (default_face_model_name,)
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalFaceModel": ComfyUIDeployExternalFaceModel}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalFaceModel": "External Face Model (ComfyUI Deploy)"
+}

comfy-nodes/external_image.py

@@ -15,6 +15,14 @@ class ComfyUIDeployExternalImage:
             },
             "optional": {
                 "default_value": ("IMAGE",),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
             }
         }
 
@@ -25,7 +33,7 @@ class ComfyUIDeployExternalImage:
 
     CATEGORY = "image"
 
-    def run(self, input_id, default_value=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None):
         image = default_value
         try:
             if input_id.startswith('http'):

comfy-nodes/external_image_alpha.py

@@ -15,6 +15,14 @@ class ComfyUIDeployExternalImageAlpha:
             },
             "optional": {
                 "default_value": ("IMAGE",),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
             }
         }
 
@@ -25,7 +33,7 @@ class ComfyUIDeployExternalImageAlpha:
 
     CATEGORY = "image"
 
-    def run(self, input_id, default_value=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None):
         image = default_value
         try:
             if input_id.startswith('http'):

comfy-nodes/external_image_batch.py

@@ -21,6 +21,14 @@ class ComfyUIDeployExternalImageBatch:
             },
             "optional": {
                 "default_value": ("IMAGE",),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
             }
         }
 
@@ -31,14 +39,34 @@ class ComfyUIDeployExternalImageBatch:
 
     CATEGORY = "image"
     
-    def run(self, input_id, images=None, default_value=None):
+    def process_image(self, image):
+        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,]
+        return image_tensor
+    
+    def run(self, input_id, images=None, default_value=None, display_name=None, description=None):
+        import requests
+        import zipfile
+        import io
+        
         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'):
+                if img_input.startswith('http') and img_input.endswith('.zip'):
-                    import requests
+                    print("Fetching zip file from url: ", img_input)
+                    response = requests.get(img_input)
+                    zip_file = zipfile.ZipFile(io.BytesIO(response.content))
+                    for file_name in zip_file.namelist():
+                        if file_name.lower().endswith(('.png', '.jpg', '.jpeg')):
+                            with zip_file.open(file_name) as file:
+                                image = Image.open(file)
+                                image = self.process_image(image)
+                                processed_images.append(image)
+                elif  img_input.startswith('http'):
                     from io import BytesIO
                     print("Fetching image from url: ", img_input)
                     response = requests.get(img_input)

comfy-nodes/external_lora.py

@@ -5,6 +5,14 @@ import torch
 import folder_paths
 
 
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+WILDCARD = AnyType("*")
+
+
 class ComfyUIDeployExternalLora:
     @classmethod
     def INPUT_TYPES(s):
@@ -17,38 +25,69 @@ class ComfyUIDeployExternalLora:
             },
             "optional": {
                 "default_lora_name": (folder_paths.get_filename_list("loras"),),
+                "lora_save_name": (  # if `default_lora_name` is a link to download a file, we will attempt to save it with this name
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+                "lora_url": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
             },
         }
 
-    RETURN_TYPES = (folder_paths.get_filename_list("loras"),)
+    RETURN_TYPES = (WILDCARD,)
     RETURN_NAMES = ("path",)
 
     FUNCTION = "run"
 
     CATEGORY = "deploy"
 
-    def run(self, input_id, default_lora_name=None):
+    def run(
+        self,
+        input_id,
+        default_lora_name=None,
+        lora_save_name=None,
+        display_name=None,
+        description=None,
+        lora_url=None,
+    ):
         import requests
         import os
         import uuid
 
-        if default_lora_name.startswith("http"):
+        if lora_url and lora_url.startswith("http"):
-            unique_filename = str(uuid.uuid4()) + ".safetensors"
+            if lora_save_name:
-            print(unique_filename)
+                existing_loras = folder_paths.get_filename_list("loras")
+                # Check if lora_save_name exists in the list
+                if lora_save_name in existing_loras:
+                    print(f"using lora: {lora_save_name}")
+                    return (lora_save_name,)
+            else:
+                lora_save_name = str(uuid.uuid4()) + ".safetensors"
+            print(lora_save_name)
             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
+                folder_paths.folder_names_and_paths["loras"][0][0], lora_save_name
             )
             print(destination_path)
-            print("Downloading external lora - " + input_id + " to " + destination_path)
+            print("Downloading external lora - " + lora_url + " to " + destination_path)
             response = requests.get(
-                input_id,
+                lora_url,
                 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,)
+            return (lora_save_name,)
         else:
             print(f"using lora: {default_lora_name}")
             return (default_lora_name,)

comfy-nodes/external_number.py

@@ -16,7 +16,15 @@ class ComfyUIDeployExternalNumber:
             "optional": {
                 "default_value": (
                     "FLOAT",
-                    {"multiline": True, "display": "number", "default": 0, "step": 0.01},
+                    {"multiline": True, "display": "number", "default": 0, "min": -2147483647, "max": 2147483647, "step": 0.01},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
                 ),
             }
         }
@@ -28,7 +36,7 @@ class ComfyUIDeployExternalNumber:
 
     CATEGORY = "number"
 
-    def run(self, input_id, default_value=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None):
         try:
             float_value = float(input_id)
             print("my number", float_value)

comfy-nodes/external_number_int.py

@@ -16,7 +16,15 @@ class ComfyUIDeployExternalNumberInt:
             "optional": {
                 "default_value": (
                     "INT",
-                    {"multiline": True, "display": "number", "default": 0},
+                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 0},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
                 ),
             }
         }
@@ -28,7 +36,7 @@ class ComfyUIDeployExternalNumberInt:
 
     CATEGORY = "number"
 
-    def run(self, input_id, default_value=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None):
         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

@@ -11,15 +11,23 @@ class ComfyUIDeployExternalNumberSlider:
             "optional": {
                 "default_value": (
                     "FLOAT",
-                    {"multiline": True, "display": "number", "default": 0.5, "step": 0.01},
+                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 0.5, "step": 0.01},
                 ),
                 "min_value": (
                     "FLOAT",
-                    {"multiline": True, "display": "number", "default": 0, "step": 0.01},
+                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 0, "step": 0.01},
                 ),
                 "max_value": (
                     "FLOAT",
-                    {"multiline": True, "display": "number", "default": 1, "step": 0.01},
+                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 1, "step": 0.01},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
                 ),
             }
         }
@@ -31,7 +39,7 @@ class ComfyUIDeployExternalNumberSlider:
 
     CATEGORY = "number"
 
-    def run(self, input_id, default_value=None, min_value=0, max_value=1):
+    def run(self, input_id, default_value=None, min_value=0, max_value=1, display_name=None, description=None):
         try:
             float_value = float(input_id)
             if min_value <= float_value <= max_value:

comfy-nodes/external_text.py

@@ -18,6 +18,14 @@ class ComfyUIDeployExternalText:
                     "STRING",
                     {"multiline": True, "default": ""},
                 ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
             }
         }
 
@@ -28,7 +36,7 @@ class ComfyUIDeployExternalText:
 
     CATEGORY = "text"
 
-    def run(self, input_id, default_value=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None):
         return [default_value]
 
 

comfy-nodes/external_text_any.py

@@ -0,0 +1,46 @@
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+WILDCARD = AnyType("*")
+
+class ComfyUIDeployExternalTextAny:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_text"},
+                ),
+            },
+            "optional": {
+                "default_value": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+            }
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "text"
+
+    def run(self, input_id, default_value=None, display_name=None, description=None):
+        return [default_value]
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalTextAny": ComfyUIDeployExternalTextAny}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalTextAny": "External Text Any (ComfyUI Deploy)"}

comfy-nodes/external_video.py

@@ -1,10 +1,15 @@
-# credit goes to https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite and is meant to work with
+# credit goes to https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite
+# Intended to work with https://github.com/NicholasKao1029/ComfyUI-VideoHelperSuite/tree/main
 import os
 import itertools
 import numpy as np
 import torch
+from typing import Union
+from torch import Tensor
 import cv2
+import psutil
 
+from collections.abc import Mapping
 import folder_paths
 from comfy.utils import common_upscale
 
@@ -90,13 +95,25 @@ if gifski_path is None:
         gifski_path = shutil.which("gifski")
 
 
+def is_safe_path(path):
+    if "VHS_STRICT_PATHS" not in os.environ:
+        return True
+    basedir = os.path.abspath(".")
+    try:
+        common_path = os.path.commonpath([basedir, path])
+    except:
+        # Different drive on windows
+        return False
+    return common_path == basedir
+
+
 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()
+    directory = strip_path(directory)
     dir_files = os.listdir(directory)
     dir_files = sorted(dir_files)
     dir_files = [os.path.join(directory, x) for x in dir_files]
@@ -177,18 +194,59 @@ def requeue_workflow(requeue_required=(-1, True)):
 
 
 def get_audio(file, start_time=0, duration=0):
-    args = [ffmpeg_path, "-v", "error", "-i", file]
+    args = [ffmpeg_path, "-i", file]
     if start_time > 0:
         args += ["-ss", str(start_time)]
     if duration > 0:
         args += ["-t", str(duration)]
     try:
+        # TODO: scan for sample rate and maintain
         res = subprocess.run(
-            args + ["-f", "wav", "-"], stdout=subprocess.PIPE, check=True
+            args + ["-f", "f32le", "-"], capture_output=True, check=True
-        ).stdout
+        )
+        audio = torch.frombuffer(bytearray(res.stdout), dtype=torch.float32)
+        match = re.search(", (\\d+) Hz, (\\w+), ", res.stderr.decode("utf-8"))
     except subprocess.CalledProcessError as e:
-        return False
+        raise Exception(
-    return res
+            f"VHS failed to extract audio from {file}:\n" + e.stderr.decode("utf-8")
+        )
+    if match:
+        ar = int(match.group(1))
+        # NOTE: Just throwing an error for other channel types right now
+        # Will deal with issues if they come
+        ac = {"mono": 1, "stereo": 2}[match.group(2)]
+    else:
+        ar = 44100
+        ac = 2
+    audio = audio.reshape((-1, ac)).transpose(0, 1).unsqueeze(0)
+    return {"waveform": audio, "sample_rate": ar}
+
+
+class LazyAudioMap(Mapping):
+    def __init__(self, file, start_time, duration):
+        self.file = file
+        self.start_time = start_time
+        self.duration = duration
+        self._dict = None
+
+    def __getitem__(self, key):
+        if self._dict is None:
+            self._dict = get_audio(self.file, self.start_time, self.duration)
+        return self._dict[key]
+
+    def __iter__(self):
+        if self._dict is None:
+            self._dict = get_audio(self.file, self.start_time, self.duration)
+        return iter(self._dict)
+
+    def __len__(self):
+        if self._dict is None:
+            self._dict = get_audio(self.file, self.start_time, self.duration)
+        return len(self._dict)
+
+
+def lazy_get_audio(file, start_time=0, duration=0):
+    return LazyAudioMap(file, start_time, duration)
 
 
 def lazy_eval(func):
@@ -230,6 +288,19 @@ def validate_sequence(path):
     return False
 
 
+def strip_path(path):
+    # This leaves whitespace inside quotes and only a single "
+    # thus ' ""test"' -> '"test'
+    # consider path.strip(string.whitespace+"\"")
+    # or weightier re.fullmatch("[\\s\"]*(.+?)[\\s\"]*", path).group(1)
+    path = path.strip()
+    if path.startswith('"'):
+        path = path[1:]
+    if path.endswith('"'):
+        path = path[:-1]
+    return path
+
+
 def hash_path(path):
     if path is None:
         return "input"
@@ -286,6 +357,145 @@ def target_size(
     return (width, height)
 
 
+def validate_index(
+    index: int,
+    length: int = 0,
+    is_range: bool = False,
+    allow_negative=False,
+    allow_missing=False,
+) -> int:
+    # if part of range, do nothing
+    if is_range:
+        return index
+    # otherwise, validate index
+    # validate not out of range - only when latent_count is passed in
+    if length > 0 and index > length - 1 and not allow_missing:
+        raise IndexError(f"Index '{index}' out of range for {length} item(s).")
+    # if negative, validate not out of range
+    if index < 0:
+        if not allow_negative:
+            raise IndexError(f"Negative indeces not allowed, but was '{index}'.")
+        conv_index = length + index
+        if conv_index < 0 and not allow_missing:
+            raise IndexError(
+                f"Index '{index}', converted to '{conv_index}' out of range for {length} item(s)."
+            )
+        index = conv_index
+    return index
+
+
+def convert_to_index_int(
+    raw_index: str,
+    length: int = 0,
+    is_range: bool = False,
+    allow_negative=False,
+    allow_missing=False,
+) -> int:
+    try:
+        return validate_index(
+            int(raw_index),
+            length=length,
+            is_range=is_range,
+            allow_negative=allow_negative,
+            allow_missing=allow_missing,
+        )
+    except ValueError as e:
+        raise ValueError(f"Index '{raw_index}' must be an integer.", e)
+
+
+def convert_str_to_indexes(
+    indexes_str: str, length: int = 0, allow_missing=False
+) -> list[int]:
+    if not indexes_str:
+        return []
+    int_indexes = list(range(0, length))
+    allow_negative = length > 0
+    chosen_indexes = []
+    # parse string - allow positive ints, negative ints, and ranges separated by ':'
+    groups = indexes_str.split(",")
+    groups = [g.strip() for g in groups]
+    for g in groups:
+        # parse range of indeces (e.g. 2:16)
+        if ":" in g:
+            index_range = g.split(":", 2)
+            index_range = [r.strip() for r in index_range]
+
+            start_index = index_range[0]
+            if len(start_index) > 0:
+                start_index = convert_to_index_int(
+                    start_index,
+                    length=length,
+                    is_range=True,
+                    allow_negative=allow_negative,
+                    allow_missing=allow_missing,
+                )
+            else:
+                start_index = 0
+            end_index = index_range[1]
+            if len(end_index) > 0:
+                end_index = convert_to_index_int(
+                    end_index,
+                    length=length,
+                    is_range=True,
+                    allow_negative=allow_negative,
+                    allow_missing=allow_missing,
+                )
+            else:
+                end_index = length
+            # support step as well, to allow things like reversing, every-other, etc.
+            step = 1
+            if len(index_range) > 2:
+                step = index_range[2]
+                if len(step) > 0:
+                    step = convert_to_index_int(
+                        step,
+                        length=length,
+                        is_range=True,
+                        allow_negative=True,
+                        allow_missing=True,
+                    )
+                else:
+                    step = 1
+            # if latents were passed in, base indeces on known latent count
+            if len(int_indexes) > 0:
+                chosen_indexes.extend(int_indexes[start_index:end_index][::step])
+            # otherwise, assume indeces are valid
+            else:
+                chosen_indexes.extend(list(range(start_index, end_index, step)))
+        # parse individual indeces
+        else:
+            chosen_indexes.append(
+                convert_to_index_int(
+                    g,
+                    length=length,
+                    allow_negative=allow_negative,
+                    allow_missing=allow_missing,
+                )
+            )
+    return chosen_indexes
+
+
+def select_indexes(input_obj: Union[Tensor, list], idxs: list):
+    if type(input_obj) == Tensor:
+        return input_obj[idxs]
+    else:
+        return [input_obj[i] for i in idxs]
+
+
+def select_indexes_from_str(
+    input_obj: Union[Tensor, list], indexes: str, err_if_missing=True, err_if_empty=True
+):
+    real_idxs = convert_str_to_indexes(
+        indexes, len(input_obj), allow_missing=not err_if_missing
+    )
+    if err_if_empty and len(real_idxs) == 0:
+        raise Exception(f"Nothing was selected based on indexes found in '{indexes}'.")
+    return select_indexes(input_obj, real_idxs)
+
+
+###
+
+
 def cv_frame_generator(
     video,
     force_rate,
@@ -295,9 +505,10 @@ def cv_frame_generator(
     meta_batch=None,
     unique_id=None,
 ):
-    video_cap = cv2.VideoCapture(video)
+    video_cap = cv2.VideoCapture(strip_path(video))
     if not video_cap.isOpened():
         raise ValueError(f"{video} could not be loaded with cv.")
+    pbar = None
 
     # extract video metadata
     fps = video_cap.get(cv2.CAP_PROP_FPS)
@@ -319,6 +530,8 @@ def cv_frame_generator(
         target_frame_time = 1 / force_rate
 
     yield (width, height, fps, duration, total_frames, target_frame_time)
+    if meta_batch is not None:
+        yield min(frame_load_cap, total_frames)
 
     time_offset = target_frame_time - base_frame_time
     while video_cap.isOpened():
@@ -349,7 +562,8 @@ def cv_frame_generator(
         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
+        frame = np.array(frame, dtype=np.float32)
+        torch.from_numpy(frame).div_(255)
         if prev_frame is not None:
             inp = yield prev_frame
             if inp is not None:
@@ -357,6 +571,8 @@ def cv_frame_generator(
                 return
         prev_frame = frame
         frames_added += 1
+        if pbar is not None:
+            pbar.update_absolute(frames_added, frame_load_cap)
         # if cap exists and we've reached it, stop processing frames
         if frame_load_cap > 0 and frames_added >= frame_load_cap:
             break
@@ -367,6 +583,17 @@ def cv_frame_generator(
         yield prev_frame
 
 
+def batched(it, n):
+    while batch := tuple(itertools.islice(it, n)):
+        yield batch
+
+
+def batched_vae_encode(images, vae, frames_per_batch):
+    for batch in batched(images, frames_per_batch):
+        image_batch = torch.from_numpy(np.array(batch))
+        yield from vae.encode(image_batch).numpy()
+
+
 def load_video_cv(
     video: str,
     force_rate: int,
@@ -378,6 +605,8 @@ def load_video_cv(
     select_every_nth: int,
     meta_batch=None,
     unique_id=None,
+    memory_limit_mb=None,
+    vae=None,
 ):
     if meta_batch is None or unique_id not in meta_batch.inputs:
         gen = cv_frame_generator(
@@ -401,30 +630,89 @@ def load_video_cv(
                 total_frames,
                 target_frame_time,
             )
+            meta_batch.total_frames = min(meta_batch.total_frames, next(gen))
 
     else:
         (gen, width, height, fps, duration, total_frames, target_frame_time) = (
             meta_batch.inputs[unique_id]
         )
 
-    if meta_batch is not None:
+    memory_limit = None
-        gen = itertools.islice(gen, meta_batch.frames_per_batch)
+    if memory_limit_mb is not None:
+        memory_limit *= 2**20
+    else:
+        # TODO: verify if garbage collection should be performed here.
+        # leaves ~128 MB unreserved for safety
+        try:
+            memory_limit = (
+                psutil.virtual_memory().available + psutil.swap_memory().free
+            ) - 2**27
+        except:
+            print(
+                "Failed to calculate available memory. Memory load limit has been disabled"
+            )
+    if memory_limit is not None:
+        if vae is not None:
+            # space required to load as f32, exist as latent with wiggle room, decode to f32
+            max_loadable_frames = int(
+                memory_limit // (width * height * 3 * (4 + 4 + 1 / 10))
+            )
+        else:
+            # TODO: use better estimate for when vae is not None
+            # Consider completely ignoring for load_latent case?
+            max_loadable_frames = int(memory_limit // (width * height * 3 * (0.1)))
+        if meta_batch is not None:
+            if meta_batch.frames_per_batch > max_loadable_frames:
+                raise RuntimeError(
+                    f"Meta Batch set to {meta_batch.frames_per_batch} frames but only {max_loadable_frames} can fit in memory"
+                )
+            gen = itertools.islice(gen, meta_batch.frames_per_batch)
+        else:
+            original_gen = gen
+            gen = itertools.islice(gen, max_loadable_frames)
+    downscale_ratio = getattr(vae, "downscale_ratio", 8)
+    frames_per_batch = (1920 * 1080 * 16) // (width * height) or 1
+    if force_size != "Disabled" or vae is not None:
+        new_size = target_size(
+            width, height, force_size, custom_width, custom_height, downscale_ratio
+        )
+        if new_size[0] != width or new_size[1] != height:
 
-    # Some minor wizardry to eliminate a copy and reduce max memory by a factor of ~2
+            def rescale(frame):
-    images = torch.from_numpy(
+                s = torch.from_numpy(
-        np.fromiter(gen, np.dtype((np.float32, (height, width, 3))))
+                    np.fromiter(frame, np.dtype((np.float32, (height, width, 3))))
-    )
+                )
+                s = s.movedim(-1, 1)
+                s = common_upscale(s, new_size[0], new_size[1], "lanczos", "center")
+                return s.movedim(1, -1).numpy()
+
+            gen = itertools.chain.from_iterable(
+                map(rescale, batched(gen, frames_per_batch))
+            )
+    else:
+        new_size = width, height
+    if vae is not None:
+        gen = batched_vae_encode(gen, vae, frames_per_batch)
+        vw, vh = new_size[0] // downscale_ratio, new_size[1] // downscale_ratio
+        images = torch.from_numpy(np.fromiter(gen, np.dtype((np.float32, (4, vh, vw)))))
+    else:
+        # 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, (new_size[1], new_size[0], 3))))
+        )
+    if meta_batch is None and memory_limit is not None:
+        try:
+            next(original_gen)
+            raise RuntimeError(
+                f"Memory limit hit after loading {len(images)} frames. Stopping execution."
+            )
+        except StopIteration:
+            pass
     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(
+    audio = lazy_get_audio(
         video,
         skip_first_frames * target_frame_time,
         frame_load_cap * target_frame_time * select_every_nth,
@@ -440,13 +728,16 @@ def load_video_cv(
         "loaded_fps": 1 / target_frame_time,
         "loaded_frame_count": len(images),
         "loaded_duration": len(images) * target_frame_time,
-        "loaded_width": images.shape[2],
+        "loaded_width": new_size[0],
-        "loaded_height": images.shape[1],
+        "loaded_height": new_size[1],
     }
-
+    if vae is None:
-    return (images, len(images), lazy_eval(audio), video_info)
+        return (images, len(images), audio, video_info, None)
+    else:
+        return (None, len(images), audio, video_info, {"samples": images})
 
 
+# modeled after Video upload node
 class ComfyUIDeployExternalVideo:
     @classmethod
     def INPUT_TYPES(s):
@@ -457,68 +748,46 @@ class ComfyUIDeployExternalVideo:
                 file_parts = f.split(".")
                 if len(file_parts) > 1 and (file_parts[-1] in video_extensions):
                     files.append(f)
-        return {
+        return {"required": {
-            "required": {
+                    "input_id": (
-                "input_id": (
+                        "STRING",
-                    "STRING",
+                        {"multiline": False, "default": "input_video"},
-                    {"multiline": False, "default": "input_video"},
+                    ),
-                ),
+                     "force_rate": ("INT", {"default": 0, "min": 0, "max": 60, "step": 1}),
-                "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"],),
-                "force_size": (
+                     "custom_width": ("INT", {"default": 512, "min": 0, "max": DIMMAX, "step": 8}),
-                    [
+                     "custom_height": ("INT", {"default": 512, "min": 0, "max": DIMMAX, "step": 8}),
-                        "Disabled",
+                     "frame_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
-                        "Custom Height",
+                     "skip_first_frames": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
-                        "Custom Width",
+                     "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
-                        "Custom",
+                     },
-                        "256x?",
+                "optional": {
-                        "?x256",
+                    "meta_batch": ("VHS_BatchManager",),
-                        "256x256",
+                    "vae": ("VAE",),
-                        "512x?",
+                    "default_video": (sorted(files),),
-                        "?x512",
+                    "display_name": (
-                        "512x512",
+                        "STRING",
-                    ],
+                        {"multiline": False, "default": ""},
-                ),
+                    ),
-                "custom_width": (
+                    "description": (
-                    "INT",
+                        "STRING",
-                    {"default": 512, "min": 0, "max": DIMMAX, "step": 8},
+                        {"multiline": True, "default": ""},
-                ),
+                    ),
-                "custom_height": (
+                },
-                    "INT",
+                "hidden": {
-                    {"default": 512, "min": 0, "max": DIMMAX, "step": 8},
+                    "unique_id": "UNIQUE_ID"
-                ),
+                },
-                "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 = (
+    RETURN_TYPES = ("IMAGE", "INT", "AUDIO", "VHS_VIDEOINFO", "LATENT")
-        "IMAGE",
-        "INT",
-        "VHS_AUDIO",
-        "VHS_VIDEOINFO",
-    )
     RETURN_NAMES = (
         "IMAGE",
         "frame_count",
         "audio",
         "video_info",
+        "LATENT",
     )
 
     FUNCTION = "load_video"
@@ -535,8 +804,6 @@ class ComfyUIDeployExternalVideo:
         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"):
@@ -566,8 +833,11 @@ class ComfyUIDeployExternalVideo:
                     leave=True,
                 ):
                     out_file.write(chunk)
-
+        else:
-        print("video path: ", video_path)
+            video = kwargs.get("default_video", None)
+            if video is None:
+                raise "No default video given and no external video provided"
+            video_path = folder_paths.get_annotated_filepath(video.strip('"'))
 
         return load_video_cv(
             video=video_path,

comfy-nodes/model_list.py

@@ -0,0 +1,60 @@
+import folder_paths
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+from os import walk
+
+WILDCARD = AnyType("*")
+
+MODEL_EXTENSIONS = {
+    "safetensors": "SafeTensors file format",
+    "ckpt": "Checkpoint file",
+    "pth": "PyTorch serialized file",
+    "pkl": "Pickle file",
+    "onnx": "ONNX file",
+}
+
+def fetch_files(path):
+    for (dirpath, dirnames, filenames) in walk(path):
+        fs = []
+        if len(dirnames) > 0:
+            for dirname in dirnames:
+                fs.extend(fetch_files(f"{dirpath}/{dirname}"))
+        for filename in filenames:
+            # Remove "./models/" from the beginning of dirpath
+            relative_dirpath = dirpath.replace("./models/", "", 1)
+            file_path = f"{relative_dirpath}/{filename}"
+            
+            # Only add files that are known model extensions
+            file_extension = filename.split('.')[-1].lower()
+            if file_extension in MODEL_EXTENSIONS:
+                fs.append(file_path)
+
+        return fs
+allModels = fetch_files("./models")
+
+class ComfyUIDeployModalList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (allModels, ),
+            }
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("model",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "model"
+
+    def run(self, model=""):
+        # Split the model path by '/' and select the last item
+        model_name = model.split('/')[-1]
+        return [model_name]
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployModelList": ComfyUIDeployModalList}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployModelList": "Model List (ComfyUI Deploy)"}

globals.py

@@ -6,10 +6,12 @@ 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"
@@ -17,6 +19,7 @@ class Status(Enum):
     FAILED = "failed"
     UPLOADING = "uploading"
 
+
 class StreamingPrompt(BaseModel):
     workflow_api: Any
     auth_token: str
@@ -24,42 +27,52 @@ class StreamingPrompt(BaseModel):
     running_prompt_ids: set[str] = set()
     status_endpoint: Optional[str]
     file_upload_endpoint: Optional[str]
-    
+    workflow: Any
+    gpu_event_id: Optional[str] = None
+
+
 class SimplePrompt(BaseModel):
     status_endpoint: Optional[str]
     file_upload_endpoint: Optional[str]
-    
+
+    token: Optional[str]
+
     workflow_api: dict
     status: Status = Status.NOT_STARTED
     progress: set = set()
-    last_updated_node: Optional[str] = None,
+    last_updated_node: Optional[str] = None
     uploading_nodes: set = set()
     done: bool = False
-    is_realtime: bool = False,
+    is_realtime: bool = False
-    start_time: Optional[float] = None,
+    start_time: Optional[float] = None
+    gpu_event_id: Optional[str] = None
+
 
 sockets = dict()
 prompt_metadata: dict[str, SimplePrompt] = {}
 streaming_prompt_metadata: dict[str, StreamingPrompt] = {}
 
+
 class BinaryEventTypes:
     PREVIEW_IMAGE = 1
     UNENCODED_PREVIEW_IMAGE = 2
-    
+
+
 max_output_id_length = 24
 
-async def send_image(image_data, sid=None, output_id:str = None):
+
+async def send_image(image_data, sid=None, output_id: str = None):
     max_length = max_output_id_length
     output_id = output_id[:max_length]
-    padded_output_id = output_id.ljust(max_length, '\x00')
+    padded_output_id = output_id.ljust(max_length, "\x00")
-    encoded_output_id = padded_output_id.encode('ascii', 'replace')
+    encoded_output_id = padded_output_id.encode("ascii", "replace")
-    
+
     image_type = image_data[0]
     image = image_data[1]
     max_size = image_data[2]
     quality = image_data[3]
     if max_size is not None:
-        if hasattr(Image, 'Resampling'):
+        if hasattr(Image, "Resampling"):
             resampling = Image.Resampling.BILINEAR
         else:
             resampling = Image.ANTIALIAS
@@ -83,17 +96,23 @@ async def send_image(image_data, sid=None, output_id:str = None):
     position_after = bytesIO.tell()
     bytes_written = position_after - position_before
     print(f"Bytes written: {bytes_written}")
-    
+
     image.save(bytesIO, format=image_type, quality=quality, compress_level=1)
     preview_bytes = bytesIO.getvalue()
     await send_bytes(BinaryEventTypes.PREVIEW_IMAGE, preview_bytes, sid=sid)
-        
+
+
 async def send_socket_catch_exception(function, message):
     try:
         await function(message)
-    except (aiohttp.ClientError, aiohttp.ClientPayloadError, ConnectionResetError) as err:
+    except (
+        aiohttp.ClientError,
+        aiohttp.ClientPayloadError,
+        ConnectionResetError,
+    ) as err:
         print("send error:", err)
 
+
 def encode_bytes(event, data):
     if not isinstance(event, int):
         raise RuntimeError(f"Binary event types must be integers, got {event}")
@@ -103,9 +122,10 @@ def encode_bytes(event, data):
     message.extend(data)
     return message
 
+
 async def send_bytes(event, data, sid=None):
     message = encode_bytes(event, data)
-    
+
     print("sending image to ", event, sid)
 
     if sid is None:
@@ -113,4 +133,4 @@ async def send_bytes(event, data, sid=None):
         for ws in _sockets:
             await send_socket_catch_exception(ws.send_bytes, message)
     elif sid in sockets:
-        await send_socket_catch_exception(sockets[sid].send_bytes, message)
+        await send_socket_catch_exception(sockets[sid].send_bytes, message)

requirements.txt

@@ -2,4 +2,5 @@ aiofiles
 pydantic
 opencv-python
 imageio-ffmpeg
-logfire
+brotli
+# logfire

web-plugin/index.js

@@ -2,6 +2,7 @@ import { app } from "./app.js";
 import { api } from "./api.js";
 import { ComfyWidgets, LGraphNode } from "./widgets.js";
 import { generateDependencyGraph } from "https://esm.sh/[email protected]";
+import { ComfyDeploy } from "https://esm.sh/[email protected]";
 
 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>`;
 
@@ -19,11 +20,8 @@ function dispatchAPIEventData(data) {
   // Custom parse error
   if (msg.error) {
     let message = msg.error.message;
-    if (msg.error.details)
+    if (msg.error.details) message += ": " + msg.error.details;
-      message += ": " + msg.error.details;
+    for (const [nodeID, nodeError] of Object.entries(msg.node_errors)) {
-    for (const [nodeID, nodeError] of Object.entries(
-      msg.node_errors,
-    )) {
       message += "\n" + nodeError.class_type + ":";
       for (const errorReason of nodeError.errors) {
         message +=
@@ -85,11 +83,52 @@ function dispatchAPIEventData(data) {
   }
 }
 
+const context = {
+  selectedWorkflowInfo: null,
+};
+// let selectedWorkflowInfo = {
+//   workflow_id: "05da8f2b-63af-4c0c-86dd-08d01ec512b7",
+//   machine_id: "45ac5f85-b7b6-436f-8d97-2383b25485f3",
+//   native_run_api_endpoint: "http://localhost:3011/api/run",
+// };
+
+async function getSelectedWorkflowInfo() {
+  const workflow_info_promise = new Promise((resolve) => {
+    try {
+      const handleMessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (message.type === "workflow_info") {
+            resolve(message.data);
+            window.removeEventListener("message", handleMessage);
+          }
+        } catch (error) {
+          console.error(error);
+          resolve(undefined);
+        }
+      };
+      window.addEventListener("message", handleMessage);
+      sendEventToCD("workflow_info");
+    } catch (error) {
+      console.error(error);
+      resolve(undefined);
+    }
+  });
+
+  return workflow_info_promise;
+}
+
+function setSelectedWorkflowInfo(info) {
+  context.selectedWorkflowInfo = info;
+}
+
 /** @typedef {import('../../../web/types/comfy.js').ComfyExtension} ComfyExtension*/
 /** @type {ComfyExtension} */
 const ext = {
   name: "BennyKok.ComfyUIDeploy",
 
+  native_mode: false,
+
   init(app) {
     addButton();
 
@@ -99,16 +138,17 @@ const ext = {
     const org_display = queryParams.get("org_display");
     const origin = queryParams.get("origin");
     const workspace_mode = queryParams.get("workspace_mode");
+    this.native_mode = queryParams.get("native_mode") === "true";
 
     if (workspace_mode) {
       document.querySelector(".comfy-menu").style.display = "none";
 
       sendEventToCD("cd_plugin_onInit");
 
-      app.queuePrompt = ((originalFunction) => async () => {
+      // app.queuePrompt = ((originalFunction) => async () => {
-        // const prompt = await app.graphToPrompt();
+      //   // const prompt = await app.graphToPrompt();
-        sendEventToCD("cd_plugin_onQueuePromptTrigger");
+      //   sendEventToCD("cd_plugin_onQueuePromptTrigger");
-      })(app.queuePrompt);
+      // })(app.queuePrompt);
 
       // // Intercept the onkeydown event
       // window.addEventListener(
@@ -194,11 +234,13 @@ const ext = {
 
   registerCustomNodes() {
     /** @type {LGraphNode}*/
-    class ComfyDeploy {
+    class ComfyDeploy extends LGraphNode {
-      color = LGraphCanvas.node_colors.yellow.color;
-      bgcolor = LGraphCanvas.node_colors.yellow.bgcolor;
-      groupcolor = LGraphCanvas.node_colors.yellow.groupcolor;
       constructor() {
+        super();
+        this.color = LGraphCanvas.node_colors.yellow.color;
+        this.bgcolor = LGraphCanvas.node_colors.yellow.bgcolor;
+        this.groupcolor = LGraphCanvas.node_colors.yellow.groupcolor;
+
         if (!this.properties) {
           this.properties = {};
           this.properties.workflow_name = "";
@@ -206,50 +248,75 @@ const ext = {
           this.properties.version = "";
         }
 
-        ComfyWidgets.STRING(
+        this.addWidget(
-          this,
+          "text",
           "workflow_name",
-          ["", { default: this.properties.workflow_name, multiline: false }],
+          this.properties.workflow_name,
-          app,
+          (v) => {
+            this.properties.workflow_name = v;
+          },
+          { multiline: false },
         );
 
-        ComfyWidgets.STRING(
+        this.addWidget(
-          this,
+          "text",
           "workflow_id",
-          ["", { default: this.properties.workflow_id, multiline: false }],
+          this.properties.workflow_id,
-          app,
+          (v) => {
+            this.properties.workflow_id = v;
+          },
+          { multiline: false },
         );
 
-        ComfyWidgets.STRING(
+        this.addWidget(
-          this,
+          "text",
           "version",
-          ["", { default: this.properties.version, multiline: false }],
+          this.properties.version,
-          app,
+          (v) => {
+            this.properties.version = v;
+          },
+          { multiline: false },
         );
 
-        // this.widgets.forEach((w) => {
-        //   // w.computeSize = () => [200,10]
-        //   w.computedHeight = 2;
-        // })
-
         this.widgets_start_y = 10;
-        this.setSize(this.computeSize());
-
-        // const config = {  };
-
-        // console.log(this);
         this.serialize_widgets = true;
         this.isVirtualNode = true;
       }
+
+      onExecute() {
+        // This method is called when the node is executed
+        // You can add any necessary logic here
+      }
+
+      onSerialize(o) {
+        // This method is called when the node is being serialized
+        // Ensure all necessary data is saved
+        if (!o.properties) {
+          o.properties = {};
+        }
+        o.properties.workflow_name = this.properties.workflow_name;
+        o.properties.workflow_id = this.properties.workflow_id;
+        o.properties.version = this.properties.version;
+      }
+
+      onConfigure(o) {
+        // This method is called when the node is being configured (e.g., when loading a saved graph)
+        // Ensure all necessary data is restored
+        if (o.properties) {
+          this.properties = { ...this.properties, ...o.properties };
+          this.widgets[0].value = this.properties.workflow_name || "";
+          this.widgets[1].value = this.properties.workflow_id || "";
+          this.widgets[2].value = this.properties.version || "1";
+        }
+      }
     }
 
-    // Load default visibility
+    // Register the node type
-
     LiteGraph.registerNodeType(
       "ComfyDeploy",
       Object.assign(ComfyDeploy, {
-        title_mode: LiteGraph.NORMAL_TITLE,
         title: "Comfy Deploy",
+        title_mode: LiteGraph.NORMAL_TITLE,
         collapsable: true,
       }),
     );
@@ -261,26 +328,116 @@ const ext = {
     // const graphCanvas = document.getElementById("graph-canvas");
 
     window.addEventListener("message", async (event) => {
+      //   console.log("message", event);
       try {
         const message = JSON.parse(event.data);
         if (message.type === "graph_load") {
           const comfyUIWorkflow = message.data;
-          console.log("recieved: ", comfyUIWorkflow);
+          // 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) {
+            try {
+              await window["app"].ui.settings.setSettingValueAsync(
+                "Comfy.Validation.Workflows",
+                false,
+              );
+            } catch (error) {
+              console.warning(
+                "Error setting validation to false, is fine to ignore this",
+                error,
+              );
+            }
+            console.log("loadGraphData");
             app.loadGraphData(comfyUIWorkflow);
           }
         } else if (message.type === "deploy") {
           // deployWorkflow();
           const prompt = await app.graphToPrompt();
+          // api.handlePromptGenerated(prompt);
           sendEventToCD("cd_plugin_onDeployChanges", prompt);
         } else if (message.type === "queue_prompt") {
           const prompt = await app.graphToPrompt();
+          if (typeof api.handlePromptGenerated === "function") {
+            api.handlePromptGenerated(prompt);
+          } else {
+            console.warn("api.handlePromptGenerated is not a function");
+          }
           sendEventToCD("cd_plugin_onQueuePrompt", prompt);
+        } else if (message.type === "get_prompt") {
+          const prompt = await app.graphToPrompt();
+          sendEventToCD("cd_plugin_onGetPrompt", prompt);
         } else if (message.type === "event") {
           dispatchAPIEventData(message.data);
+        } else if (message.type === "add_node") {
+          console.log("add node", message.data);
+          app.graph.beforeChange();
+          var node = LiteGraph.createNode(message.data.type);
+          node.configure({
+            widgets_values: message.data.widgets_values,
+          });
+
+          console.log("node", node);
+
+          const graphMouse = app.canvas.graph_mouse;
+
+          node.pos = [graphMouse[0], graphMouse[1]];
+
+          app.graph.add(node);
+          app.graph.afterChange();
+        } else if (message.type === "zoom_to_node") {
+          const nodeId = message.data.nodeId;
+          const position = message.data.position;
+
+          const node = app.graph.getNodeById(nodeId);
+          if (!node) return;
+
+          const canvas = app.canvas;
+          const targetScale = 1;
+          const targetOffsetX =
+            canvas.canvas.width / 4 - position[0] - node.size[0] / 2;
+          const targetOffsetY =
+            canvas.canvas.height / 4 - position[1] - node.size[1] / 2;
+
+          const startScale = canvas.ds.scale;
+          const startOffsetX = canvas.ds.offset[0];
+          const startOffsetY = canvas.ds.offset[1];
+
+          const duration = 400; // Animation duration in milliseconds
+          const startTime = Date.now();
+
+          function easeOutCubic(t) {
+            return 1 - Math.pow(1 - t, 3);
+          }
+
+          function lerp(start, end, t) {
+            return start * (1 - t) + end * t;
+          }
+
+          function animate() {
+            const currentTime = Date.now();
+            const elapsedTime = currentTime - startTime;
+            const t = Math.min(elapsedTime / duration, 1);
+
+            const easedT = easeOutCubic(t);
+
+            const currentScale = lerp(startScale, targetScale, easedT);
+            const currentOffsetX = lerp(startOffsetX, targetOffsetX, easedT);
+            const currentOffsetY = lerp(startOffsetY, targetOffsetY, easedT);
+
+            canvas.setZoom(currentScale);
+            canvas.ds.offset = [currentOffsetX, currentOffsetY];
+            canvas.draw(true, true);
+
+            if (t < 1) {
+              requestAnimationFrame(animate);
+            }
+          }
+
+          animate();
+        } else if (message.type === "workflow_info") {
+          setSelectedWorkflowInfo(message.data);
         }
         // else if (message.type === "refresh") {
         //   sendEventToCD("cd_plugin_onRefresh");
@@ -288,10 +445,6 @@ const ext = {
       } catch (error) {
         // console.error("Error processing message:", error);
       }
-
-      // if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
-      //   return;
-      //   updateBlendshapesPrompts(event.data.flow);
     });
 
     api.addEventListener("executed", (evt) => {
@@ -304,6 +457,25 @@ const ext = {
       //   }
     });
 
+    if (this.native_mode) {
+      // console.log("native mode", window, window.app);
+      try {
+        await app.ui.settings.setSettingValueAsync("Comfy.UseNewMenu", "Top");
+        await app.ui.settings.setSettingValueAsync(
+          "Comfy.Sidebar.Size",
+          "small"
+        );
+        await app.ui.settings.setSettingValueAsync(
+          "Comfy.Sidebar.Location",
+          "right"
+        );
+        localStorage.setItem("Comfy.MenuPosition.Docked", "true");
+        console.log("native mode manmanman");
+      } catch (error) {
+        console.error("Error setting validation to false", error);
+      }
+    }
+
     app.graph.onAfterChange = ((originalFunction) =>
       async function () {
         const prompt = await app.graphToPrompt();
@@ -415,6 +587,7 @@ function createDynamicUIHtml(data) {
   return html;
 }
 
+// Modify the existing deployWorkflow function
 async function deployWorkflow() {
   const deploy = document.getElementById("deploy-button");
 
@@ -561,30 +734,30 @@ async function deployWorkflow() {
         console.log(hash);
         return hash.file_hash;
       },
-      handleFileUpload: async (file, hash, prevhash) => {
+      //   handleFileUpload: async (file, hash, prevhash) => {
-        console.log("Uploading ", file);
+      //     console.log("Uploading ", file);
-        loadingDialog.showLoading("Uploading file", file);
+      //     loadingDialog.showLoading("Uploading file", file);
-        try {
+      //     try {
-          const { download_url } = await fetch(`/comfyui-deploy/upload-file`, {
+      //       const { download_url } = await fetch(`/comfyui-deploy/upload-file`, {
-            method: "POST",
+      //         method: "POST",
-            body: JSON.stringify({
+      //         body: JSON.stringify({
-              file_path: file,
+      //           file_path: file,
-              token: apiKey,
+      //           token: apiKey,
-              url: endpoint + "/api/upload-url",
+      //           url: endpoint + "/api/upload-url",
-            }),
+      //         }),
-          })
+      //       })
-            .then((x) => x.json())
+      //         .then((x) => x.json())
-            .catch(() => {
+      //         .catch(() => {
-              loadingDialog.close();
+      //           loadingDialog.close();
-              confirmDialog.confirm("Error", "Unable to upload file " + file);
+      //           confirmDialog.confirm("Error", "Unable to upload file " + file);
-            });
+      //         });
-          loadingDialog.showLoading("Uploaded file", file);
+      //       loadingDialog.showLoading("Uploaded file", file);
-          console.log(download_url);
+      //       console.log(download_url);
-          return download_url;
+      //       return download_url;
-        } catch (error) {
+      //     } catch (error) {
-          return undefined;
+      //       return undefined;
-        }
+      //     }
-      },
+      //   },
       existingDependencies: existing_workflow.dependencies,
     });
 
@@ -609,6 +782,15 @@ async function deployWorkflow() {
       "Check dependencies",
       // JSON.stringify(deps, null, 2),
       `
+      <div>
+        You will need to create a cloud machine with the following configuration on ComfyDeploy
+        <ol style="text-align: left; margin-top: 10px;">
+            <li>Review the dependencies listed in the graph below</li>
+            <li>Create a new cloud machine with the required configuration</li>
+            <li>Install missing models and check missing files</li>
+            <li>Deploy your workflow to the newly created machine</li>
+        </ol>
+      </div>
       <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">${loadingIcon}</div>
       <iframe 
       style="z-index: 10; min-width: 600px; max-width: 1024px; min-height: 600px; border: none; background-color: transparent;"
@@ -678,6 +860,14 @@ async function deployWorkflow() {
       `<span style="color:green;">Deployed successfully!</span>  <a style="color:white;" target="_blank" href=${endpoint}/workflows/${data.workflow_id}>-> View here</a> <br/> <br/> Workflow ID: ${data.workflow_id} <br/> Workflow Name: ${workflow_name} <br/> Workflow Version: ${data.version} <br/>`,
     );
 
+    // // Refresh the workflows list in the sidebar
+    // const sidebarEl = document.querySelector(
+    //   '.comfy-sidebar-tab[data-id="search"]',
+    // );
+    // if (sidebarEl) {
+    //   refreshWorkflowsList(sidebarEl);
+    // }
+
     setTimeout(() => {
       title.textContent = "Deploy";
       title.style.color = "white";
@@ -695,6 +885,85 @@ async function deployWorkflow() {
   }
 }
 
+// Add this function to refresh the workflows list
+function refreshWorkflowsList(el) {
+  const workflowsList = el.querySelector("#workflows-list");
+  const workflowsLoading = el.querySelector("#workflows-loading");
+
+  workflowsLoading.style.display = "flex";
+  workflowsList.style.display = "none";
+  workflowsList.innerHTML = "";
+
+  client.workflows
+    .getAll({
+      page: "1",
+      pageSize: "10",
+    })
+    .then((result) => {
+      workflowsLoading.style.display = "none";
+      workflowsList.style.display = "block";
+
+      if (result.length === 0) {
+        workflowsList.innerHTML =
+          "<li style='color: #bdbdbd;'>No workflows found</li>";
+        return;
+      }
+
+      result.forEach((workflow) => {
+        const li = document.createElement("li");
+        li.style.marginBottom = "15px";
+        li.style.padding = "15px";
+        li.style.backgroundColor = "#2a2a2a";
+        li.style.borderRadius = "8px";
+        li.style.boxShadow = "0 2px 4px rgba(0,0,0,0.1)";
+
+        const lastRun = workflow.runs[0];
+        const lastRunStatus = lastRun ? lastRun.status : "No runs";
+        const statusColor =
+          lastRunStatus === "success"
+            ? "#4CAF50"
+            : lastRunStatus === "error"
+              ? "#F44336"
+              : "#FFC107";
+
+        const timeAgo = getTimeAgo(new Date(workflow.updatedAt));
+
+        li.innerHTML = `
+          <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
+            <div style="flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;">
+              <strong style="font-size: 18px; color: #e0e0e0;">${workflow.name}</strong>
+            </div>
+            <span style="font-size: 12px; color: ${statusColor}; margin-left: 10px;">Last run: ${lastRunStatus}</span>
+          </div>
+          <div style="font-size: 14px; color: #bdbdbd; margin-bottom: 10px;">Last updated ${timeAgo}</div>
+          <div style="display: flex; gap: 10px;">
+            <button class="open-cloud-btn" style="padding: 5px 10px; background-color: #4CAF50; color: white; border: none; border-radius: 4px; cursor: pointer;">Open in Cloud</button>
+            <button class="load-api-btn" style="padding: 5px 10px; background-color: #2196F3; color: white; border: none; border-radius: 4px; cursor: pointer;">Load Workflow</button>
+          </div>
+        `;
+
+        const openCloudBtn = li.querySelector(".open-cloud-btn");
+        openCloudBtn.onclick = () =>
+          window.open(
+            `${getData().endpoint}/workflows/${workflow.id}?workspace=true`,
+            "_blank",
+          );
+
+        const loadApiBtn = li.querySelector(".load-api-btn");
+        loadApiBtn.onclick = () => loadWorkflowApi(workflow.versions[0].id);
+
+        workflowsList.appendChild(li);
+      });
+    })
+    .catch((error) => {
+      console.error("Error fetching workflows:", error);
+      workflowsLoading.style.display = "none";
+      workflowsList.style.display = "block";
+      workflowsList.innerHTML =
+        "<li style='color: #F44336;'>Error fetching workflows</li>";
+    });
+}
+
 function addButton() {
   const menu = document.querySelector(".comfy-menu");
 
@@ -1187,3 +1456,153 @@ export class ConfigDialog extends ComfyDialog {
 }
 
 export const configDialog = new ConfigDialog();
+
+const currentOrigin = window.location.origin;
+const client = new ComfyDeploy({
+  bearerAuth: getData().apiKey,
+  serverURL: `${currentOrigin}/comfydeploy/api/`,
+});
+
+app.extensionManager.registerSidebarTab({
+  id: "search",
+  icon: "pi pi-cloud-upload",
+  title: "Deploy",
+  tooltip: "Deploy and Configure",
+  type: "custom",
+  render: (el) => {
+    el.innerHTML = `
+      <div style="padding: 20px;">
+        <h3>Comfy Deploy</h3>
+        <div id="deploy-container" style="margin-bottom: 20px;"></div>
+        <div id="workflows-container">
+          <h4>Your Workflows</h4>
+          <div id="workflows-loading" style="display: flex; justify-content: center; align-items: center; height: 100px;">
+            ${loadingIcon}
+          </div>
+          <ul id="workflows-list" style="list-style-type: none; padding: 0; display: none;"></ul>
+        </div>
+        <div id="config-container"></div>
+      </div>
+    `;
+
+    // Add deploy button
+    const deployContainer = el.querySelector("#deploy-container");
+    const deployButton = document.createElement("button");
+    deployButton.id = "sidebar-deploy-button";
+    deployButton.style.display = "flex";
+    deployButton.style.alignItems = "center";
+    deployButton.style.justifyContent = "center";
+    deployButton.style.width = "100%";
+    deployButton.style.marginBottom = "10px";
+    deployButton.style.padding = "10px";
+    deployButton.style.fontSize = "16px";
+    deployButton.style.fontWeight = "bold";
+    deployButton.style.backgroundColor = "#4CAF50";
+    deployButton.style.color = "white";
+    deployButton.style.border = "none";
+    deployButton.style.borderRadius = "5px";
+    deployButton.style.cursor = "pointer";
+    deployButton.innerHTML = `<i class="pi pi-cloud-upload" style="margin-right: 8px;"></i><div id='sidebar-button-title'>Deploy</div>`;
+    deployButton.onclick = async () => {
+      await deployWorkflow();
+      // Refresh the workflows list after deployment
+      refreshWorkflowsList(el);
+    };
+    deployContainer.appendChild(deployButton);
+
+    // Add config button
+    const configContainer = el.querySelector("#config-container");
+    const configButton = document.createElement("button");
+    configButton.style.display = "flex";
+    configButton.style.alignItems = "center";
+    configButton.style.justifyContent = "center";
+    configButton.style.width = "100%";
+    configButton.style.padding = "8px";
+    configButton.style.fontSize = "14px";
+    configButton.style.backgroundColor = "#f0f0f0";
+    configButton.style.color = "#333";
+    configButton.style.border = "1px solid #ccc";
+    configButton.style.borderRadius = "5px";
+    configButton.style.cursor = "pointer";
+    configButton.innerHTML = `<i class="pi pi-cog" style="margin-right: 8px;"></i>Configure`;
+    configButton.onclick = () => {
+      configDialog.show();
+    };
+    deployContainer.appendChild(configButton);
+
+    // Fetch and display workflows
+    const workflowsList = el.querySelector("#workflows-list");
+    const workflowsLoading = el.querySelector("#workflows-loading");
+
+    refreshWorkflowsList(el);
+  },
+});
+
+function getTimeAgo(date) {
+  const seconds = Math.floor((new Date() - date) / 1000);
+  let interval = seconds / 31536000;
+  if (interval > 1) return Math.floor(interval) + " years ago";
+  interval = seconds / 2592000;
+  if (interval > 1) return Math.floor(interval) + " months ago";
+  interval = seconds / 86400;
+  if (interval > 1) return Math.floor(interval) + " days ago";
+  interval = seconds / 3600;
+  if (interval > 1) return Math.floor(interval) + " hours ago";
+  interval = seconds / 60;
+  if (interval > 1) return Math.floor(interval) + " minutes ago";
+  return Math.floor(seconds) + " seconds ago";
+}
+
+async function loadWorkflowApi(versionId) {
+  try {
+    const response = await client.comfyui.getWorkflowVersionVersionId({
+      versionId: versionId,
+    });
+    // Implement the logic to load the workflow API into the ComfyUI interface
+    console.log("Workflow API loaded:", response);
+    await window["app"].ui.settings.setSettingValueAsync(
+      "Comfy.Validation.Workflows",
+      false,
+    );
+    app.loadGraphData(response.workflow);
+    // You might want to update the UI or trigger some action in ComfyUI here
+  } catch (error) {
+    console.error("Error loading workflow API:", error);
+    // Show an error message to the user
+  }
+}
+
+const orginal_fetch_api = api.fetchApi;
+api.fetchApi = async (route, options) => {
+  console.log("Fetch API called with args:", route, options, ext.native_mode);
+
+  if (route.startsWith("/prompt") && ext.native_mode) {
+    const info = await getSelectedWorkflowInfo();
+    console.log("info", info);
+    if (info) {
+      const body = JSON.parse(options.body);
+
+      const data = {
+        client_id: body.client_id,
+        workflow_api_json: body.prompt,
+        workflow: body?.extra_data?.extra_pnginfo?.workflow,
+        is_native_run: true,
+        machine_id: info.machine_id,
+        workflow_id: info.workflow_id,
+        native_run_api_endpoint: info.native_run_api_endpoint,
+        gpu_event_id: info.gpu_event_id,
+      };
+
+      return await fetch("/comfyui-deploy/run", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${info.cd_token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(data),
+      });
+    }
+  }
+
+  return await orginal_fetch_api.call(api, route, options);
+};

web/package.json

@@ -74,7 +74,7 @@
     "mitata": "^0.1.6",
     "ms": "^2.1.3",
     "nanoid": "^5.0.4",
-    "next": "14.1",
+    "next": "14.2",
     "next-plausible": "^3.12.0",
     "next-themes": "^0.2.1",
     "next-usequerystate": "^1.13.2",

web/src/components/customInputNodes.tsx

@@ -6,4 +6,5 @@ export const customInputNodes: Record<string, string> = {
   ComfyUIDeployExternalNumberInt: "integer",
   ComfyUIDeployExternalLora: "string - (public lora download url)",
   ComfyUIDeployExternalCheckpoint: "string - (public checkpoints download url)",
+  ComfyUIDeployExternalFaceModel: "string - (public face model download url)",
 };

web/src/routes/registerCreateRunRoute.ts

@@ -51,7 +51,9 @@ const createRunRoute = createRoute({
 export const registerCreateRunRoute = (app: App) => {
   app.openapi(createRunRoute, async (c) => {
     const data = c.req.valid("json");
-    const origin = new URL(c.req.url).origin;
+    const proto = c.req.headers.get('x-forwarded-proto')  || "http";
+    const host = c.req.headers.get('x-forwarded-host') || c.req.headers.get('host');
+    const origin = `${proto}://${host}` || new URL(c.req.url).origin;
     const apiKeyTokenData = c.get("apiKeyTokenData")!;
 
     const { deployment_id, inputs } = data;

web/src/server/createRun.ts

@@ -102,7 +102,7 @@ export const createRun = withServerPromise(
 
     let prompt_id: string | undefined = undefined;
     const shareData = {
-      workflow_api: workflow_api,
+      workflow_api_raw: workflow_api,
       status_endpoint: `${origin}/api/update-run`,
       file_upload_endpoint: `${origin}/api/file-upload`,
     };