Update Dockerfile

adding Postgres port env var

.github/workflows/publish.yml

@@ -1,21 +0,0 @@
-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

@@ -1,35 +0,0 @@
-class ComfyUIDeployExternalBoolean:
-    @classmethod    
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": "input_bool"},
-                ),
-                "default_value": ("BOOLEAN", {"default": False})
-            },
-            "optional": {
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("BOOLEAN",)
-    RETURN_NAMES = ("bool_value",)
-    
-    FUNCTION = "run"
-    
-    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]
-    
-
-NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalBoolean": ComfyUIDeployExternalBoolean}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalBoolean": "External Boolean (ComfyUI Deploy)"}

comfy-nodes/external_checkpoints.py

@@ -5,12 +5,6 @@ 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):
@@ -23,25 +17,17 @@ class ComfyUIDeployExternalCheckpoint:
             },
             "optional": {
                 "default_value": (folder_paths.get_filename_list("checkpoints"), ),
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
             }
         }
 
-    RETURN_TYPES = (WILDCARD,)
+    RETURN_TYPES = (folder_paths.get_filename_list("checkpoints"),)
     RETURN_NAMES = ("path",)
 
     FUNCTION = "run"
 
     CATEGORY = "deploy"
 
-    def run(self, input_id, default_value=None, display_name=None, description=None):
+    def run(self, input_id, default_value=None):
         import requests
         import os
         import uuid

comfy-nodes/external_image.py

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

comfy-nodes/external_image_alpha.py

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

comfy-nodes/external_image_batch.py

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

comfy-nodes/external_lora.py

@@ -5,14 +5,6 @@ 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):
@@ -24,76 +16,36 @@ 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": ""},
-                ),
-            },
+                "default_lora_name": (folder_paths.get_filename_list("loras"), ),
+            }
         }
 
-    RETURN_TYPES = (WILDCARD,)
+    RETURN_TYPES = (folder_paths.get_filename_list("loras"),)
     RETURN_NAMES = ("path",)
 
     FUNCTION = "run"
 
     CATEGORY = "deploy"
 
-    def run(
-        self,
-        input_id,
-        default_lora_name=None,
-        lora_save_name=None,
-        display_name=None,
-        description=None,
-        lora_url=None,
-    ):
+    def run(self, input_id, default_lora_name=None):
         import requests
         import os
         import uuid
 
-        if lora_url and lora_url.startswith("http"):
-            if lora_save_name:
-                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)
+        if input_id and input_id.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], lora_save_name
-            )
+            destination_path = os.path.join(folder_paths.folder_names_and_paths["loras"][0][0], unique_filename)
             print(destination_path)
-            print("Downloading external lora - " + lora_url + " to " + destination_path)
-            response = requests.get(
-                lora_url,
-                headers={"User-Agent": "Mozilla/5.0"},
-                allow_redirects=True,
-            )
-            with open(destination_path, "wb") as out_file:
+            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:
                 out_file.write(response.content)
-            return (lora_save_name,)
+            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.py

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

comfy-nodes/external_number_int.py

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

comfy-nodes/external_number_slider.py

@@ -1,56 +0,0 @@
-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", "min": -2147483647, "max": 2147483647, "default": 0.5, "step": 0.01},
-                ),
-                "min_value": (
-                    "FLOAT",
-                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 0, "step": 0.01},
-                ),
-                "max_value": (
-                    "FLOAT",
-                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 1, "step": 0.01},
-                ),
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("FLOAT",)
-    RETURN_NAMES = ("value",)
-
-    FUNCTION = "run"
-
-    CATEGORY = "number"
-
-    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:
-                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_text.py

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

comfy-nodes/external_text_list.py

@@ -1,52 +0,0 @@
-import folder_paths
-from PIL import Image, ImageOps
-import numpy as np
-import torch
-import json
-
-class ComfyUIDeployExternalTextList:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": 'input_text_list'},
-                ),
-                 "text": (
-                    "STRING",
-                    {"multiline": True, "default": "[]"},
-                ),
-            },
-            "optional": {
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("STRING",)
-    RETURN_NAMES = ("text",)
-
-    OUTPUT_IS_LIST = (True,)
-
-    FUNCTION = "run"
-
-    CATEGORY = "text"
-
-    def run(self, input_id, text=None, display_name=None, description=None):
-        text_list = []
-        try:
-            text_list = json.loads(text)  # Assuming text is a JSON array string
-        except Exception as e:
-            print(f"Error processing images: {e}")
-            pass
-        return ([text_list],)
-
-NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalTextList": ComfyUIDeployExternalTextList}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalTextList": "External Text List (ComfyUI Deploy)"}

comfy-nodes/external_vid.py

@@ -1,78 +0,0 @@
-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

@@ -1,864 +0,0 @@
-# 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
-
-### 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 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 = 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]
-    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, "-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", "f32le", "-"], capture_output=True, check=True
-        )
-        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:
-        raise Exception(
-            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):
-    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 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"
-    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 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,
-    frame_load_cap,
-    skip_first_frames,
-    select_every_nth,
-    meta_batch=None,
-    unique_id=None,
-):
-    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)
-    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)
-    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():
-        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)
-        torch.from_numpy(frame).div_(255)
-        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 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
-    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 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,
-    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,
-    memory_limit_mb=None,
-    vae=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,
-            )
-            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]
-        )
-
-    memory_limit = None
-    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:
-
-            def rescale(frame):
-                s = torch.from_numpy(
-                    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")
-
-    # Setup lambda for lazy audio capture
-    audio = lazy_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": new_size[0],
-        "loaded_height": new_size[1],
-    }
-    if vae is None:
-        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):
-        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",),
-                    "vae": ("VAE",),
-                    "default_video": (sorted(files),),
-                    "display_name": (
-                        "STRING",
-                        {"multiline": False, "default": ""},
-                    ),
-                    "description": (
-                        "STRING",
-                        {"multiline": True, "default": ""},
-                    ),
-                },
-                "hidden": {
-                    "unique_id": "UNIQUE_ID"
-                },
-                }
-
-    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
-
-    RETURN_TYPES = ("IMAGE", "INT", "AUDIO", "VHS_VIDEOINFO", "LATENT")
-    RETURN_NAMES = (
-        "IMAGE",
-        "frame_count",
-        "audio",
-        "video_info",
-        "LATENT",
-    )
-
-    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")
-
-
-        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 = 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,
-            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)"
-}

docker-compose.yaml

@@ -0,0 +1,55 @@
+version: '3.9'
+services:
+
+  comfy-deploy:
+    build:
+      context: .
+      dockerfile: ./local/Dockerfile
+    restart: unless-stopped
+    volumes:
+      - ./local/scripts/entrypoint.sh:/comfyui-deploy/web/deploy_entrypoint.sh
+    entrypoint: /comfyui-deploy/web/deploy_entrypoint.sh
+    ports:
+      - 3000:3000
+    depends_on:
+      - postgres
+      - pg_proxy
+      - localstack
+    environment:
+      VSCODE_DEV_CONTAINER: true
+
+
+### comfy-deploy services
+
+  postgres:
+      image: "postgres:15.2-alpine"
+      environment:
+        POSTGRES_USER: postgres
+        POSTGRES_PASSWORD: postgres
+        POSTGRES_DB: verceldb
+        POSTGRES_PORT: 5480
+      expose:
+        - 5480
+
+
+  pg_proxy:
+    image: ghcr.io/neondatabase/wsproxy:latest
+    environment:
+      APPEND_PORT: "postgres:5480"
+      ALLOW_ADDR_REGEX: ".*"
+      LOG_TRAFFIC: "true"
+    expose:
+      - 80
+    depends_on:
+      - postgres
+
+
+  localstack:
+    image: localstack/localstack:latest
+    environment:
+      SERVICES: s3
+    ports:
+      - 4566:4566
+    volumes:
+      - ../localstack/aws:/etc/localstack/init/ready.d
+      - ../localstack/aws:/app/web/aws

globals.py

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

local/Dockerfile

@@ -0,0 +1,18 @@
+FROM node:21-bullseye AS comfy_deploy
+
+RUN apt-get update && apt-get install -y python3 make g++
+
+RUN npm install -g bun
+
+COPY ./web /web
+
+
+WORKDIR /web
+
+RUN cp .env.example .env.local
+
+RUN bunx node-gyp
+
+RUN bun i
+
+ENTRYPOINT [ "bun", "dev" ]

local/scripts/entrypoint.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+echo "comfy deploy container starting.."
+
+echo "Running migrations.."
+bun migrate-local
+
+echo "Starting comfy deploy.."
+bun dev

prestartup_script.py

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

pyproject.toml

@@ -1,15 +0,0 @@
-[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,6 +1,2 @@
 aiofiles
 pydantic
-opencv-python
-imageio-ffmpeg
-brotli
-# logfire

web-plugin/index.js

@@ -1,88 +1,10 @@
 import { app } from "./app.js";
 import { api } from "./api.js";
 import { ComfyWidgets, LGraphNode } from "./widgets.js";
-import { generateDependencyGraph } from "https://esm.sh/[email protected]5";
-import { ComfyDeploy } from "https://esm.sh/[email protected]";
+import { generateDependencyGraph } from "https://esm.sh/[email protected]2";
 
 const loadingIcon = `<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><g fill="none" stroke="#888888" stroke-linecap="round" stroke-width="2"><path stroke-dasharray="60" stroke-dashoffset="60" stroke-opacity=".3" d="M12 3C16.9706 3 21 7.02944 21 12C21 16.9706 16.9706 21 12 21C7.02944 21 3 16.9706 3 12C3 7.02944 7.02944 3 12 3Z"><animate fill="freeze" attributeName="stroke-dashoffset" dur="1.3s" values="60;0"/></path><path stroke-dasharray="15" stroke-dashoffset="15" d="M12 3C16.9706 3 21 7.02944 21 12"><animate fill="freeze" attributeName="stroke-dashoffset" dur="0.3s" values="15;0"/><animateTransform attributeName="transform" dur="1.5s" repeatCount="indefinite" type="rotate" values="0 12 12;360 12 12"/></path></g></svg>`;
 
-function sendEventToCD(event, data) {
-  const message = {
-    type: event,
-    data: data,
-  };
-  window.parent.postMessage(JSON.stringify(message), "*");
-}
-
-function dispatchAPIEventData(data) {
-  const msg = JSON.parse(data);
-
-  // Custom parse error
-  if (msg.error) {
-    let message = msg.error.message;
-    if (msg.error.details) message += ": " + msg.error.details;
-    for (const [nodeID, nodeError] of Object.entries(msg.node_errors)) {
-      message += "\n" + nodeError.class_type + ":";
-      for (const errorReason of nodeError.errors) {
-        message +=
-          "\n    - " + errorReason.message + ": " + errorReason.details;
-      }
-    }
-
-    app.ui.dialog.show(message);
-    if (msg.node_errors) {
-      app.lastNodeErrors = msg.node_errors;
-      app.canvas.draw(true, true);
-    }
-  }
-
-  switch (msg.event) {
-    case "error":
-      break;
-    case "status":
-      if (msg.data.sid) {
-        // this.clientId = msg.data.sid;
-        // window.name = this.clientId; // use window name so it isnt reused when duplicating tabs
-        // sessionStorage.setItem("clientId", this.clientId); // store in session storage so duplicate tab can load correct workflow
-      }
-      api.dispatchEvent(new CustomEvent("status", { detail: msg.data.status }));
-      break;
-    case "progress":
-      api.dispatchEvent(new CustomEvent("progress", { detail: msg.data }));
-      break;
-    case "executing":
-      api.dispatchEvent(
-        new CustomEvent("executing", { detail: msg.data.node }),
-      );
-      break;
-    case "executed":
-      api.dispatchEvent(new CustomEvent("executed", { detail: msg.data }));
-      break;
-    case "execution_start":
-      api.dispatchEvent(
-        new CustomEvent("execution_start", { detail: msg.data }),
-      );
-      break;
-    case "execution_error":
-      api.dispatchEvent(
-        new CustomEvent("execution_error", { detail: msg.data }),
-      );
-      break;
-    case "execution_cached":
-      api.dispatchEvent(
-        new CustomEvent("execution_cached", { detail: msg.data }),
-      );
-      break;
-    default:
-      api.dispatchEvent(new CustomEvent(msg.type, { detail: msg.data }));
-    // default:
-    // if (this.#registered.has(msg.type)) {
-    // } else {
-    // throw new Error(`Unknown message type ${msg.type}`);
-    // }
-  }
-}
-
 /** @typedef {import('../../../web/types/comfy.js').ComfyExtension} ComfyExtension*/
 /** @type {ComfyExtension} */
 const ext = {
@@ -96,34 +18,6 @@ const ext = {
     const auth_token = queryParams.get("auth_token");
     const org_display = queryParams.get("org_display");
     const origin = queryParams.get("origin");
-    const workspace_mode = queryParams.get("workspace_mode");
-
-    if (workspace_mode) {
-      document.querySelector(".comfy-menu").style.display = "none";
-
-      sendEventToCD("cd_plugin_onInit");
-
-      app.queuePrompt = ((originalFunction) => async () => {
-        // const prompt = await app.graphToPrompt();
-        sendEventToCD("cd_plugin_onQueuePromptTrigger");
-      })(app.queuePrompt);
-
-      // // Intercept the onkeydown event
-      // window.addEventListener(
-      //   "keydown",
-      //   (event) => {
-      //     // Check for specific keys if necessary
-      //     console.log("hi");
-      //     if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
-      //       event.preventDefault();
-      //       event.stopImmediatePropagation();
-      //       event.stopPropagation();
-      //       sendEventToCD("cd_plugin_onQueuePrompt", prompt);
-      //     }
-      //   },
-      //   true,
-      // );
-    }
 
     const data = getData();
     let endpoint = data.endpoint;
@@ -192,13 +86,11 @@ const ext = {
 
   registerCustomNodes() {
     /** @type {LGraphNode}*/
-    class ComfyDeploy extends LGraphNode {
+    class ComfyDeploy {
+      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,75 +98,53 @@ const ext = {
           this.properties.version = "";
         }
 
-        this.addWidget(
-          "text",
+        ComfyWidgets.STRING(
+          this,
           "workflow_name",
-          this.properties.workflow_name,
-          (v) => {
-            this.properties.workflow_name = v;
-          },
-          { multiline: false }
+          ["", { default: this.properties.workflow_name, multiline: false }],
+          app,
         );
 
-        this.addWidget(
-          "text",
+        ComfyWidgets.STRING(
+          this,
           "workflow_id",
-          this.properties.workflow_id,
-          (v) => {
-            this.properties.workflow_id = v;
-          },
-          { multiline: false }
+          ["", { default: this.properties.workflow_id, multiline: false }],
+          app,
         );
 
-        this.addWidget(
-          "text",
+        ComfyWidgets.STRING(
+          this,
           "version",
-          this.properties.version,
-          (v) => {
-            this.properties.version = v;
-          },
-          { multiline: false }
+          ["", { default: this.properties.version, multiline: false }],
+          app,
         );
 
+        // 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;
-      }
+    // Load default visibility
 
-      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";
-        }
-      }
-    }
-
-    // Register the node type
-    LiteGraph.registerNodeType("ComfyDeploy", Object.assign(ComfyDeploy, {
-      title: "Comfy Deploy",
+    LiteGraph.registerNodeType(
+      "ComfyDeploy",
+      Object.assign(ComfyDeploy, {
         title_mode: LiteGraph.NORMAL_TITLE,
+        title: "Comfy Deploy",
         collapsable: true,
-    }));
+      }),
+    );
 
     ComfyDeploy.category = "deploy";
   },
@@ -282,111 +152,10 @@ const ext = {
   async setup() {
     // 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);
-          // 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) {
-            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 === "refresh") {
-        //   sendEventToCD("cd_plugin_onRefresh");
-        // }
-      } catch (error) {
-        // console.error("Error processing message:", error);
-      }
+    window.addEventListener("message", (event) => {
+      if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
+        return;
+      //   updateBlendshapesPrompts(event.data.flow);
     });
 
     api.addEventListener("executed", (evt) => {
@@ -398,18 +167,6 @@ const ext = {
 
       //   }
     });
-
-    app.graph.onAfterChange = ((originalFunction) =>
-      async function () {
-        const prompt = await app.graphToPrompt();
-        sendEventToCD("cd_plugin_onAfterChange", prompt);
-
-        if (typeof originalFunction === "function") {
-          originalFunction.apply(this, arguments);
-        }
-      })(app.graph.onAfterChange);
-
-    sendEventToCD("cd_plugin_setup");
   },
 };
 
@@ -454,11 +211,14 @@ function createDynamicUIHtml(data) {
   Object.values(data.custom_nodes).forEach((node) => {
     html += `
           <div style="border-bottom: 1px solid #e2e8f0; padding-top: 16px;">
-              <a href="${node.url
-      }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${node.name
+              <a href="${
+                node.url
+              }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${
+                node.name
               }</a>
               <p style="font-size: 14px; color: #4b5563;">${node.hash}</p>
-              ${node.warning
+              ${
+                node.warning
                   ? `<p style="font-size: 14px; color: #d69e2e;">${node.warning}</p>`
                   : ""
               }
@@ -475,7 +235,8 @@ function createDynamicUIHtml(data) {
   Object.entries(data.models).forEach(([section, items]) => {
     html += `
     <div style="border-bottom: 1px solid #e2e8f0; padding-top: 8px; padding-bottom: 8px;">
-        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${
+          section.charAt(0).toUpperCase() + section.slice(1)
         }</h3>`;
     items.forEach((item) => {
       html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
@@ -492,7 +253,8 @@ function createDynamicUIHtml(data) {
   Object.entries(data.files).forEach(([section, items]) => {
     html += `
     <div style="border-bottom: 1px solid #e2e8f0; padding-top: 8px; padding-bottom: 8px;">
-        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${
+          section.charAt(0).toUpperCase() + section.slice(1)
         }</h3>`;
     items.forEach((item) => {
       html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
@@ -505,10 +267,14 @@ function createDynamicUIHtml(data) {
   return html;
 }
 
-// Modify the existing deployWorkflow function
-async function deployWorkflow() {
-  const deploy = document.getElementById("deploy-button");
+function addButton() {
+  const menu = document.querySelector(".comfy-menu");
 
+  const deploy = document.createElement("button");
+  deploy.style.position = "relative";
+  deploy.style.display = "block";
+  deploy.innerHTML = "<div id='button-title'>Deploy</div>";
+  deploy.onclick = async () => {
     /** @type {LGraph} */
     const graph = app.graph;
 
@@ -646,36 +412,41 @@ 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);
           return hash.file_hash;
         },
-      //   handleFileUpload: async (file, hash, prevhash) => {
-      //     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",
-      //         }),
-      //       })
-      //         .then((x) => x.json())
-      //         .catch(() => {
-      //           loadingDialog.close();
-      //           confirmDialog.confirm("Error", "Unable to upload file " + file);
-      //         });
-      //       loadingDialog.showLoading("Uploaded file", file);
-      //       console.log(download_url);
-      //       return download_url;
-      //     } catch (error) {
-      //       return undefined;
-      //     }
-      //   },
+        handleFileUpload: async (file, hash, prevhash) => {
+          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",
+                }),
+              },
+            )
+              .then((x) => x.json())
+              .catch(() => {
+                loadingDialog.close();
+                confirmDialog.confirm("Error", "Unable to upload file " + file);
+              });
+            loadingDialog.showLoading("Uploaded file", file);
+            console.log(download_url);
+            return download_url;
+          } catch (error) {
+            return undefined;
+          }
+        },
         existingDependencies: existing_workflow.dependencies,
       });
 
@@ -700,15 +471,6 @@ 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;"
@@ -778,14 +540,6 @@ 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";
@@ -801,97 +555,6 @@ async function deployWorkflow() {
         title.style.color = "white";
       }, 1000);
     }
-}
-
-// 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");
-
-  const deploy = document.createElement("button");
-  deploy.id = "deploy-button";
-  deploy.style.position = "relative";
-  deploy.style.display = "block";
-  deploy.innerHTML = "<div id='button-title'>Deploy</div>";
-  deploy.onclick = async () => {
-    await deployWorkflow();
   };
 
   const config = document.createElement("img");
@@ -1013,9 +676,11 @@ export class LoadingDialog extends ComfyDialog {
   showLoading(title, message) {
     this.show(`
       <div style="width: 400px; display: flex; gap: 18px; flex-direction: column; overflow: unset">
-        <h3 style="margin: 0px; display: flex; align-items: center; justify-content: center; gap: 12px;">${title} ${this.loadingIcon
+        <h3 style="margin: 0px; display: flex; align-items: center; justify-content: center; gap: 12px;">${title} ${
+          this.loadingIcon
         }</h3>
-          ${message
+          ${
+            message
               ? `<label style="max-width: 100%; white-space: pre-wrap; word-wrap: break-word;">${message}</label>`
               : ""
           }
@@ -1284,16 +949,20 @@ export class ConfigDialog extends ComfyDialog {
     </label>
       <label style="color: white; width: 100%;">
         Endpoint:
-        <input id="endpoint" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="text" value="${data.endpoint
+        <input id="endpoint" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="text" value="${
+          data.endpoint
         }">
       </label>
       <div style="color: white;">
-        API Key: User / Org <button style="font-size: 18px;">${data.displayName ?? ""
+        API Key: User / Org <button style="font-size: 18px;">${
+          data.displayName ?? ""
         }</button>
-        <input id="apiKey" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="password" value="${data.apiKey
+        <input id="apiKey" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="password" value="${
+          data.apiKey
         }">
         <button id="loginButton" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;">
-          ${data.apiKey ? "Re-login with ComfyDeploy" : "Login with ComfyDeploy"
+          ${
+            data.apiKey ? "Re-login with ComfyDeploy" : "Login with ComfyDeploy"
           }
         </button>
       </div>
@@ -1368,118 +1037,3 @@ 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
-  }
-}

web/package.json

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

web/src/db/db.ts

@@ -9,10 +9,10 @@ if (process.env.VERCEL_ENV !== "production") {
   // Set the WebSocket proxy to work with the local instance
   if (isDevContainer) {
     // Running inside a VS Code devcontainer
-    neonConfig.wsProxy = (host) => "host.docker.internal:5481/v1";
+    neonConfig.wsProxy = (host) => "pg_proxy:80/v1";
   } else {
     // Not running inside a VS Code devcontainer
-    neonConfig.wsProxy = (host) => `${host}:5481/v1`;
+    neonConfig.wsProxy = (host) => "pg_proxy:80/v1";
   }
   // Disable all authentication and encryption
   neonConfig.useSecureWebSocket = false;

web/src/routes/registerCreateRunRoute.ts

@@ -51,9 +51,7 @@ const createRunRoute = createRoute({
 export const registerCreateRunRoute = (app: App) => {
   app.openapi(createRunRoute, async (c) => {
     const data = c.req.valid("json");
-    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 origin = 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_raw: workflow_api,
+      workflow_api: workflow_api,
       status_endpoint: `${origin}/api/update-run`,
       file_upload_endpoint: `${origin}/api/file-upload`,
     };