fix

.github/workflows/publish.yml

@@ -7,19 +7,15 @@ on:
     paths:
       - "pyproject.toml"
 
-permissions:
-  issues: write
-
 jobs:
   publish-node:
     name: Publish Custom Node to registry
     runs-on: ubuntu-latest
-    if: ${{ github.repository_owner == 'BennyKok' }}
     steps:
       - name: Check out code
         uses: actions/checkout@v4
       - name: Publish Custom Node
-        uses: Comfy-Org/publish-node-action@v1
+        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 }}
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

README.md

@@ -2,8 +2,6 @@
 
 Open source comfyui deployment platform, a `vercel` for generative workflow infra. (serverless hosted gpu with vertical intergation with comfyui)
 
-Check out our latest lcoal demo -> https://github.com/comfy-deploy/comfyui-api-comfydeploy
-
 > [!NOTE]  
 > Im looking for creative hacker to join ComfyDeploy's core team! DM me on [twitter](https://x.com/BennyKokMusic)
 

__init__.py

@@ -2,9 +2,8 @@
 @author: BennyKok
 @title: comfyui-deploy
 @nickname: Comfy Deploy
-@description:
+@description: 
 """
-
 import os
 import sys
 
@@ -18,23 +17,19 @@ import requests
 import folder_paths
 from folder_paths import add_model_folder_path, get_filename_list, get_folder_paths
 from tqdm import tqdm
-import re
 
 from . import custom_routes
 # import routes
 
 ag_path = os.path.join(os.path.dirname(__file__))
 
-
 def get_python_files(path):
     return [f[:-3] for f in os.listdir(path) if f.endswith(".py")]
 
-
 def append_to_sys_path(path):
     if path not in sys.path:
         sys.path.append(path)
 
-
 paths = ["comfy-nodes"]
 files = []
 
@@ -46,45 +41,14 @@ for path in paths:
 NODE_CLASS_MAPPINGS = {}
 NODE_DISPLAY_NAME_MAPPINGS = {}
 
-
-def split_camel_case(name):
-    # Split on underscores first, then split each part on camelCase
-    parts = []
-    for part in name.split("_"):
-        # Find all camelCase boundaries
-        words = re.findall("[A-Z][^A-Z]*", part)
-        if not words:  # If no camelCase found, use the whole part
-            words = [part]
-        parts.extend(words)
-    return parts
-
-
 # Import all the modules and append their mappings
 for file in files:
     module = importlib.import_module(file)
 
-    # Check if the module has explicit mappings
     if hasattr(module, "NODE_CLASS_MAPPINGS"):
         NODE_CLASS_MAPPINGS.update(module.NODE_CLASS_MAPPINGS)
     if hasattr(module, "NODE_DISPLAY_NAME_MAPPINGS"):
         NODE_DISPLAY_NAME_MAPPINGS.update(module.NODE_DISPLAY_NAME_MAPPINGS)
 
-    # Auto-discover classes with ComfyUI node attributes
-    for name, obj in inspect.getmembers(module):
-        # Check if it's a class and has the required ComfyUI node attributes
-        if (
-            inspect.isclass(obj)
-            and hasattr(obj, "INPUT_TYPES")
-            and hasattr(obj, "RETURN_TYPES")
-        ):
-            # Use the class name as the key if not already in mappings
-            if name not in NODE_CLASS_MAPPINGS:
-                NODE_CLASS_MAPPINGS[name] = obj
-                # Create a display name by converting camelCase to Title Case with spaces
-                words = split_camel_case(name.replace("ComfyUIDeploy", ""))
-                display_name = " ".join(word.capitalize() for word in words)
-                # print(display_name, name)
-                NODE_DISPLAY_NAME_MAPPINGS[name] = display_name
-
 WEB_DIRECTORY = "web-plugin"
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

comfy-nodes/external_audio.py

@@ -1,13 +1,14 @@
+import os
 import io
+import torchaudio
 from folder_paths import get_annotated_filepath
 
-
 class ComfyUIDeployExternalAudio:
     RETURN_TYPES = ("AUDIO",)
     RETURN_NAMES = ("audio",)
     FUNCTION = "load_audio"
     CATEGORY = "🔗ComfyDeploy"
-
+    
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -28,55 +29,30 @@ class ComfyUIDeployExternalAudio:
                     "STRING",
                     {"multiline": False, "default": ""},
                 ),
-            },
+            }
         }
-
+    
     @classmethod
     def VALIDATE_INPUTS(s, audio_file, **kwargs):
         return True
 
-    def load_audio(
-        self,
-        input_id,
-        audio_file,
-        default_value=None,
-        display_name=None,
-        description=None,
-    ):
-        try:
-            import torchaudio
-
-            if audio_file and audio_file != "":
-                if audio_file.startswith(("http://", "https://")):
-                    # Handle URL input
-                    try:
-                        import requests
-
-                        response = requests.get(audio_file)
-                        audio_data = io.BytesIO(response.content)
-                        waveform, sample_rate = torchaudio.load(audio_data)
-                    except Exception as e:
-                        print(f"Error loading audio from URL: {e}")
-                        return (default_value,)
-                else:
-                    # Handle local file
-                    try:
-                        audio_path = get_annotated_filepath(audio_file)
-                        waveform, sample_rate = torchaudio.load(audio_path)
-                    except Exception as e:
-                        print(f"Error loading local audio file: {e}")
-                        return (default_value,)
-
-                audio = {"waveform": waveform.unsqueeze(0), "sample_rate": sample_rate}
-                return (audio,)
+    def load_audio(self, input_id, audio_file, default_value=None, display_name=None, description=None):
+        if audio_file and audio_file != "":
+            if audio_file.startswith(('http://', 'https://')):
+                # Handle URL input
+                import requests
+                response = requests.get(audio_file)
+                audio_data = io.BytesIO(response.content)
+                waveform, sample_rate = torchaudio.load(audio_data)
             else:
-                return (default_value,)
-        except ImportError as e:
-            print(f"Error: torchaudio not installed or cannot be imported: {e}")
+                # Handle local file
+                audio_path = get_annotated_filepath(audio_file)
+                waveform, sample_rate = torchaudio.load(audio_path)
+            
+            audio = {"waveform": waveform.unsqueeze(0), "sample_rate": sample_rate}
+            return (audio,)
+        else:
             return (default_value,)
 
-
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalAudio": ComfyUIDeployExternalAudio}
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "ComfyUIDeployExternalAudio": "External Audio (ComfyUI Deploy)"
-}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalAudio": "External Audio (ComfyUI Deploy)"}

comfy-nodes/external_enum.py

@@ -1,46 +0,0 @@
-class AnyType(str):
-    def __ne__(self, __value: object) -> bool:
-        return False
-
-
-WILDCARD = AnyType("*")
-
-class ComfyUIDeployExternalEnum:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": "input_enum"},
-                ),
-            },
-            "optional": {
-                "default_value": (
-                    "STRING",
-                    {"multiline": False, "default": "", "dynamic_enum": True},
-                ),
-                "options": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
-            }
-        }
-
-    RETURN_TYPES = (WILDCARD,)
-    RETURN_NAMES = ("text",)
-
-    FUNCTION = "run"
-
-    CATEGORY = "🔗ComfyDeploy"
-
-    def run(self, input_id, options=None, default_value=None, display_name=None, description=None):
-        return [default_value]

comfy-nodes/external_lora.py

@@ -1,4 +1,8 @@
 import folder_paths
+from PIL import Image, ImageOps
+import numpy as np
+import torch
+import folder_paths
 
 
 class AnyType(str):
@@ -37,10 +41,6 @@ class ComfyUIDeployExternalLora:
                     "STRING",
                     {"multiline": False, "default": ""},
                 ),
-                "bearer_token": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
             },
         }
 
@@ -57,7 +57,6 @@ class ComfyUIDeployExternalLora:
         display_name=None,
         description=None,
         lora_url=None,
-        bearer_token=None,
     ):
         import requests
         import os
@@ -85,13 +84,9 @@ class ComfyUIDeployExternalLora:
                     + " to "
                     + destination_path
                 )
-                headers = {"User-Agent": "Mozilla/5.0"}
-                if bearer_token:
-                    headers["Authorization"] = f"Bearer {bearer_token}"
-                    print("using bearer token")
                 response = requests.get(
                     lora_url,
-                    headers=headers,
+                    headers={"User-Agent": "Mozilla/5.0"},
                     allow_redirects=True,
                 )
                 with open(destination_path, "wb") as out_file:

comfy-nodes/external_number_slider_int.py

@@ -1,54 +0,0 @@
-class ComfyUIDeployExternalNumberSliderInt:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": "input_number_slider_int"},
-                ),
-            },
-            "optional": {
-                "default_value": (
-                    "INT",
-                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 1, "step": 1},
-                ),
-                "min_value": (
-                    "INT",
-                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 0, "step": 1},
-                ),
-                "max_value": (
-                    "INT",
-                    {"multiline": True, "display": "number", "min": -2147483647, "max": 2147483647, "default": 10, "step": 1},
-                ),
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("INT",)
-    RETURN_NAMES = ("value",)
-    FUNCTION = "run"
-    CATEGORY = "🔗ComfyDeploy"
-
-    def run(self, input_id, default_value=None, min_value=0, max_value=10, display_name=None, description=None):
-        try:
-            int_value = int(round(float(input_id)))
-            if min_value <= int_value <= max_value:
-                print("my integer", int_value)
-                return [int_value]
-            else:
-                print("Integer out of range. Returning default value:", default_value)
-                return [default_value]
-        except (ValueError, TypeError):
-            print("Invalid input. Returning default value:", default_value)
-            return [default_value]
-
-NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalNumberSliderInt": ComfyUIDeployExternalNumberSliderInt}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalNumberSliderInt": "External Number Slider Int (ComfyUI Deploy)"}

comfy-nodes/external_seed.py

@@ -1,116 +0,0 @@
-import random
-
-
-class ComfyUIDeployExternalSeed:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": "input_seed"},
-                ),
-                "default_value": (
-                    "INT",
-                    {"default": -1},
-                ),
-                "min_value": (
-                    "INT",
-                    {"default": 1, "min": 1, "max": 999999999999999},
-                ),
-                "max_value": (
-                    "INT",
-                    {"default": 4294967295, "min": 1, "max": 999999999999999},
-                ),
-            },
-            "optional": {
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {
-                        "multiline": True,
-                        "default": 'For default value:\n"-1" (i.e. not in range): Randomize within the min and max value range. \nin range: Fixed, always the same value\n',
-                    },
-                ),
-            },
-        }
-
-    RETURN_TYPES = ("INT",)
-    RETURN_NAMES = ("seed",)
-    FUNCTION = "run"
-    CATEGORY = "🔗ComfyDeploy"
-
-    # Limits
-    _MAX_LIMIT = 999_999_999_999_999  # 15 digits
-
-    # Store cached seed when fixed flag is enabled
-    _cached_seed = None
-
-    @classmethod
-    def IS_CHANGED(
-        cls,
-        input_id,
-        min_value,
-        max_value,
-        default_value=None,
-        **kwargs,
-    ):
-        """Inform ComfyUI whether the node output should be considered changed.
-
-        If default_value is within range (Fixed mode), we return the inputs tuple
-        so the cached result is reused until the user changes something.
-        For Randomize mode, we force re-execution each queue.
-        """
-        # Clamp values to allowed range for check
-        min_value = max(1, min_value)
-        max_value = min(cls._MAX_LIMIT, max_value)
-
-        # Fixed mode when default_value is within range
-        if (
-            default_value is not None
-            and default_value >= min_value
-            and default_value <= max_value
-        ):
-            return (input_id, default_value)
-
-        # For Randomize (default_value is -1 or out of range) we force re-execution
-        import random as _rnd
-
-        return _rnd.random()
-
-    def run(
-        self,
-        input_id,
-        min_value: int,
-        max_value: int,
-        display_name=None,
-        description=None,
-        default_value: int = -1,
-    ):
-        # Clamp values to allowed range
-        min_value = max(1, min_value)
-        max_value = min(self._MAX_LIMIT, max_value)
-
-        # Ensure limits are in correct order after clamping
-        if min_value > max_value:
-            min_value, max_value = max_value, min_value
-
-        # Fixed mode: default_value is within range
-        if default_value >= min_value and default_value <= max_value:
-            seed = int(default_value)
-            self._cached_seed = seed
-            return [seed]
-
-        # Randomize mode: default_value is -1 or out of range
-        seed = random.randint(min_value, max_value)
-        self._cached_seed = seed
-        return [seed]
-
-
-NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalSeed": ComfyUIDeployExternalSeed}
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "ComfyUIDeployExternalSeed": "External Seed (ComfyUI Deploy)"
-}

comfy-nodes/external_video.py

@@ -748,64 +748,36 @@ class ComfyUIDeployExternalVideo:
                 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": ""},
-                ),
-                "default_value_url": ("STRING", {"image_preview": True, "default": ""}),
-            },
-            "hidden": {"unique_id": "UNIQUE_ID"},
-        }
+        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 🎥🅥🅗🅢"
 
@@ -832,21 +804,16 @@ class ComfyUIDeployExternalVideo:
         select_every_nth = kwargs.get("select_every_nth")
         meta_batch = kwargs.get("meta_batch")
         unique_id = kwargs.get("unique_id")
-        default_value_url = kwargs.get("default_value_url")
+
 
         input_dir = folder_paths.get_input_directory()
-        if input_id.startswith("http") or (
-            default_value_url and default_value_url.startswith("http")
-        ):
+        if input_id.startswith("http"):
             import requests
 
-            # Use input_id if it's a URL, otherwise use default_value_url
-            url = input_id if input_id.startswith("http") else default_value_url
-
-            print("Fetching video from URL: ", url)
-            response = requests.get(url, stream=True)
+            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 = url.split(".")[-1].split("?")[
+            file_extension = input_id.split(".")[-1].split("?")[
                 0
             ]  # Extract extension and handle URLs with parameters
             if file_extension not in video_extensions:

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 = "🔗ComfyDeploy"
+
+    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)"}

comfy-nodes/output_exr.py

@@ -1,78 +0,0 @@
-# In file: comfyui-deploy/comfy-nodes/output_exr.py
-
-import os
-import numpy as np
-import folder_paths
-
-# Try to set up OpenCV for EXR writing.
-try:
-    os.environ["OPENCV_IO_ENABLE_OPENEXR"] = "1"
-    import cv2
-    OPENCV_AVAILABLE = True
-except ImportError:
-    print("Warning: OpenCV not found for ComfyDeployOutputEXR. Please add opencv-python-headless to requirements.txt")
-    OPENCV_AVAILABLE = False
-
-# ALIGNED: Renamed class to match project conventions
-class ComfyDeployOutputEXR:
-    def __init__(self):
-        self.output_dir = folder_paths.get_output_directory()
-        self.type = "output"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "images": ("IMAGE", ),
-                "filename_prefix": ("STRING", {"default": "ComfyDeploy_EXR"})
-            },
-            # ADDED: Optional output_id for consistency with other ComfyDeploy nodes
-            "optional": {
-                "output_id": ("STRING", {"multiline": False, "default": "output_exr"}),
-            },
-        }
-    
-    RETURN_TYPES = ()
-    # ALIGNED: Changed function name to 'run'
-    FUNCTION = "run"
-    OUTPUT_NODE = True
-    # ALIGNED: Matched the category name
-    CATEGORY = "🔗ComfyDeploy"
-    DESCRIPTION = "Saves the input images as EXR (HDR) files."
-
-    def run(self, images, filename_prefix="ComfyDeploy_EXR", output_id="output_exr"):
-        if not OPENCV_AVAILABLE:
-            raise ImportError("OpenCV is required to save EXR files. Please ensure opencv-python-headless is in requirements.txt.")
-
-        full_output_folder, filename, counter, subfolder, filename_prefix = (
-            folder_paths.get_save_image_path(
-                filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
-            )
-        )
-        results = list()
-
-        for image in images:
-            image_np = image.cpu().numpy()
-
-            if image_np.dtype != np.float32:
-                 image_np = image_np.astype(np.float32)
-
-            file = f"{filename}_{counter:05}.exr"
-            file_path = os.path.join(full_output_folder, file)
-
-            image_np_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
-            cv2.imwrite(file_path, image_np_bgr)
-
-            results.append({
-                "filename": file,
-                "subfolder": subfolder,
-                "type": self.type,
-                "output_id": output_id, # ADDED
-            })
-            counter += 1
-
-        return {"ui": {"images": results}}
-
-# ALIGNED: Mappings are defined at the bottom of the node file in this project
-NODE_CLASS_MAPPINGS = {"ComfyDeployOutputEXR": ComfyDeployOutputEXR}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyDeployOutputEXR": "EXR Output (ComfyDeploy)"}

comfy-nodes/output_text.py

@@ -1,99 +0,0 @@
-import os
-import json
-import folder_paths
-
-
-class ComfyDeployOutputText:
-    def __init__(self):
-        self.output_dir = folder_paths.get_output_directory()
-        self.type = "output"
-        self.prefix_append = ""
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "text": (
-                    "STRING",
-                    {
-                        "multiline": True,
-                        "forceInput": True,
-                        "tooltip": "The text to save.",
-                    },
-                ),
-                "filename_prefix": (
-                    "STRING",
-                    {
-                        "default": "ComfyUI",
-                        "tooltip": "The prefix for the file to save. This may include formatting information such as %date:yyyy-MM-dd% to include values from nodes.",
-                    },
-                ),
-                "file_type": (["txt", "json", "md"], {"default": "txt"}),
-            },
-            "optional": {
-                "output_id": (
-                    "STRING",
-                    {"multiline": False, "default": "output_text"},
-                ),
-            },
-            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
-        }
-
-    RETURN_TYPES = ()
-    FUNCTION = "run"
-
-    OUTPUT_NODE = True
-    CATEGORY = "🔗ComfyDeploy"
-    DESCRIPTION = "Saves the input text to your ComfyUI output directory."
-
-    def run(
-        self,
-        text,
-        filename_prefix="ComfyUI",
-        file_type="txt",
-        output_id="output_text",
-        prompt=None,
-        extra_pnginfo=None,
-    ):
-        filename_prefix += self.prefix_append
-        # For text, we don't need dimensions, so pass 0, 0
-        full_output_folder, filename, counter, subfolder, filename_prefix = (
-            folder_paths.get_save_image_path(filename_prefix, self.output_dir, 0, 0)
-        )
-
-        results = list()
-
-        # Create file path
-        file = f"{filename}_{counter:05}_.{file_type}"
-        file_path = os.path.join(full_output_folder, file)
-
-        # Save the text based on file type
-        if file_type == "json":
-            try:
-                # Try to save as JSON if the text is valid JSON
-                json_data = json.loads(text) if isinstance(text, str) else text
-                with open(file_path, "w", encoding="utf-8") as f:
-                    json.dump(json_data, f, indent=2)
-            except json.JSONDecodeError:
-                # Fall back to saving as plain text if not valid JSON
-                with open(file_path, "w", encoding="utf-8") as f:
-                    f.write(text)
-        else:
-            # Save as plain text for txt and md
-            with open(file_path, "w", encoding="utf-8") as f:
-                f.write(text)
-
-        results.append(
-            {
-                "filename": file,
-                "subfolder": subfolder,
-                "type": self.type,
-                "output_id": output_id,
-            }
-        )
-
-        return {"ui": {"text_file": results}}
-
-
-NODE_CLASS_MAPPINGS = {"ComfyDeployOutputText": ComfyDeployOutputText}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyDeployOutputText": "Text Output (ComfyDeploy)"}

example_workflows/lora-model.json

@@ -1,152 +0,0 @@
-{
-  "id": "ed93ac94-4f26-4ed3-a57b-73cd8f4d3494",
-  "revision": 0,
-  "last_node_id": 5,
-  "last_link_id": 1,
-  "nodes": [
-    {
-      "id": 2,
-      "type": "LoraLoader",
-      "pos": [
-        736.646728515625,
-        628.3823852539062
-      ],
-      "size": [
-        315,
-        126
-      ],
-      "flags": {},
-      "order": 2,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "model",
-          "type": "MODEL",
-          "link": null
-        },
-        {
-          "name": "clip",
-          "type": "CLIP",
-          "link": null
-        },
-        {
-          "name": "lora_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "lora_name"
-          },
-          "link": 1
-        }
-      ],
-      "outputs": [
-        {
-          "name": "MODEL",
-          "type": "MODEL",
-          "links": null
-        },
-        {
-          "name": "CLIP",
-          "type": "CLIP",
-          "links": null
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "LoraLoader"
-      },
-      "widgets_values": [
-        "1-292.safetensors",
-        1,
-        1
-      ]
-    },
-    {
-      "id": 1,
-      "type": "ComfyUIDeployExternalLora",
-      "pos": [
-        299.6898498535156,
-        624.7929077148438
-      ],
-      "size": [
-        400,
-        208
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "path",
-          "type": "*",
-          "links": [
-            1
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfyui-deploy",
-        "ver": "cd3a2ff5471828f9c840e746551592e882c05aa4",
-        "Node name for S&R": "ComfyUIDeployExternalLora"
-      },
-      "widgets_values": [
-        "input_lora",
-        "HyperSD\\FLUX.1\\Hyper-FLUX.1-dev-16steps-lora.safetensors",
-        "",
-        "",
-        "",
-        ""
-      ]
-    },
-    {
-      "id": 5,
-      "type": "Note",
-      "pos": [
-        302.09033203125,
-        401.2951965332031
-      ],
-      "size": [
-        479.4894104003906,
-        161.61924743652344
-      ],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [],
-      "properties": {},
-      "widgets_values": [
-        "\"External Lora\" node will let you to use different loras from the Comfy Deploy UI or even via API.\n\n- lora_url:\n  url that will be used to download your LoRA model in execution time\n\n- lora_save_name:\n  when we download your model, this will be saved in your private storage, \n  give it a good name :D"
-      ],
-      "color": "#432",
-      "bgcolor": "#653"
-    }
-  ],
-  "links": [
-    [
-      1,
-      1,
-      0,
-      2,
-      2,
-      "COMBO"
-    ]
-  ],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": {
-      "scale": 1.167184107045006,
-      "offset": [
-        298.431389807788,
-        -207.58877445762934
-      ]
-    },
-    "VHS_latentpreview": false,
-    "VHS_latentpreviewrate": 0,
-    "VHS_MetadataImage": true,
-    "VHS_KeepIntermediate": true
-  },
-  "version": 0.4
-}

example_workflows/masks.json

@@ -1,873 +0,0 @@
-{
-  "id": "351f402b-62f2-4f62-8a5e-0b9d3510e8f9",
-  "revision": 0,
-  "last_node_id": 29,
-  "last_link_id": 28,
-  "nodes": [
-    {
-      "id": 11,
-      "type": "JoinImageWithAlpha",
-      "pos": [
-        814.478271484375,
-        419.3052062988281
-      ],
-      "size": [
-        264.5999755859375,
-        46
-      ],
-      "flags": {},
-      "order": 5,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": 10
-        },
-        {
-          "name": "alpha",
-          "type": "MASK",
-          "link": 12
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            11
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "JoinImageWithAlpha"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 15,
-      "type": "PreviewImage",
-      "pos": [
-        1950,
-        640
-      ],
-      "size": [
-        210,
-        246
-      ],
-      "flags": {},
-      "order": 18,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 16
-        }
-      ],
-      "outputs": [],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "PreviewImage"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 10,
-      "type": "LoadImage",
-      "pos": [
-        467.8168640136719,
-        422.453857421875
-      ],
-      "size": [
-        315,
-        314
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            10
-          ]
-        },
-        {
-          "name": "MASK",
-          "type": "MASK",
-          "links": [
-            12
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "LoadImage"
-      },
-      "widgets_values": [
-        "Bob-Minion-Background-PNG-Image.png",
-        "image",
-        ""
-      ]
-    },
-    {
-      "id": 18,
-      "type": "Note",
-      "pos": [
-        460.8001708984375,
-        263.64251708984375
-      ],
-      "size": [
-        379.4292297363281,
-        88
-      ],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [],
-      "properties": {},
-      "widgets_values": [
-        "Option 1: CREATE THE MASK FROM THE ALPHA CHANNEL (Useful for example to generate the background of an image)\n\nMake sure that you are using \"External Image Alpha\". \n"
-      ],
-      "color": "#432",
-      "bgcolor": "#653"
-    },
-    {
-      "id": 21,
-      "type": "LoadImage",
-      "pos": [
-        469.57025146484375,
-        1506.3018798828125
-      ],
-      "size": [
-        315,
-        314
-      ],
-      "flags": {},
-      "order": 2,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            18
-          ]
-        },
-        {
-          "name": "MASK",
-          "type": "MASK",
-          "links": null
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "LoadImage"
-      },
-      "widgets_values": [
-        "ComfyUI_temp_otmos_00005_.png",
-        "image",
-        ""
-      ]
-    },
-    {
-      "id": 25,
-      "type": "MaskToImage",
-      "pos": [
-        1283.1668701171875,
-        1579.603271484375
-      ],
-      "size": [
-        176.39999389648438,
-        26
-      ],
-      "flags": {},
-      "order": 13,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "mask",
-          "type": "MASK",
-          "link": 28
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            21
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "MaskToImage"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 13,
-      "type": "SplitImageWithAlpha",
-      "pos": [
-        1602.5518798828125,
-        417.59869384765625
-      ],
-      "size": [
-        277.20001220703125,
-        46
-      ],
-      "flags": {},
-      "order": 11,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": 13
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            14,
-            25
-          ]
-        },
-        {
-          "name": "MASK",
-          "type": "MASK",
-          "links": [
-            15,
-            26
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "SplitImageWithAlpha"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 29,
-      "type": "VAEEncodeForInpaint",
-      "pos": [
-        2220.89453125,
-        401.0885009765625
-      ],
-      "size": [
-        340.20001220703125,
-        98
-      ],
-      "flags": {},
-      "order": 16,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "pixels",
-          "type": "IMAGE",
-          "link": 25
-        },
-        {
-          "name": "vae",
-          "type": "VAE",
-          "link": null
-        },
-        {
-          "name": "mask",
-          "type": "MASK",
-          "link": 26
-        }
-      ],
-      "outputs": [
-        {
-          "name": "LATENT",
-          "type": "LATENT",
-          "links": null
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "VAEEncodeForInpaint"
-      },
-      "widgets_values": [
-        6
-      ]
-    },
-    {
-      "id": 14,
-      "type": "PreviewImage",
-      "pos": [
-        1950,
-        350
-      ],
-      "size": [
-        210,
-        246
-      ],
-      "flags": {},
-      "order": 14,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 14
-        }
-      ],
-      "outputs": [],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "PreviewImage"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 17,
-      "type": "MaskToImage",
-      "pos": [
-        1752.33203125,
-        572.061767578125
-      ],
-      "size": [
-        176.39999389648438,
-        26
-      ],
-      "flags": {},
-      "order": 15,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "mask",
-          "type": "MASK",
-          "link": 15
-        }
-      ],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            16
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "MaskToImage"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 27,
-      "type": "PreviewImage",
-      "pos": [
-        1329.2960205078125,
-        1132.759765625
-      ],
-      "size": [
-        210,
-        246
-      ],
-      "flags": {},
-      "order": 10,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 22
-        }
-      ],
-      "outputs": [],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "PreviewImage"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 20,
-      "type": "LoadImage",
-      "pos": [
-        468.1963806152344,
-        1128.9498291015625
-      ],
-      "size": [
-        315,
-        314
-      ],
-      "flags": {},
-      "order": 3,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            17
-          ]
-        },
-        {
-          "name": "MASK",
-          "type": "MASK",
-          "links": []
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "LoadImage"
-      },
-      "widgets_values": [
-        "clipspace/clipspace-mask-1126817.300000012.png [input]",
-        "image",
-        ""
-      ]
-    },
-    {
-      "id": 24,
-      "type": "ImageToMask",
-      "pos": [
-        1255.560302734375,
-        1468.347900390625
-      ],
-      "size": [
-        315,
-        58
-      ],
-      "flags": {},
-      "order": 9,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": 19
-        }
-      ],
-      "outputs": [
-        {
-          "name": "MASK",
-          "type": "MASK",
-          "links": [
-            24,
-            28
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "ImageToMask"
-      },
-      "widgets_values": [
-        "red"
-      ]
-    },
-    {
-      "id": 26,
-      "type": "PreviewImage",
-      "pos": [
-        1488.1925048828125,
-        1579.146728515625
-      ],
-      "size": [
-        210,
-        246
-      ],
-      "flags": {},
-      "order": 17,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 21
-        }
-      ],
-      "outputs": [],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "PreviewImage"
-      },
-      "widgets_values": []
-    },
-    {
-      "id": 28,
-      "type": "VAEEncodeForInpaint",
-      "pos": [
-        1637.603271484375,
-        1182.81298828125
-      ],
-      "size": [
-        340.20001220703125,
-        98
-      ],
-      "flags": {},
-      "order": 12,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "pixels",
-          "type": "IMAGE",
-          "link": 23
-        },
-        {
-          "name": "vae",
-          "type": "VAE",
-          "link": null
-        },
-        {
-          "name": "mask",
-          "type": "MASK",
-          "link": 24
-        }
-      ],
-      "outputs": [
-        {
-          "name": "LATENT",
-          "type": "LATENT",
-          "links": null
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfy-core",
-        "ver": "0.3.27",
-        "Node name for S&R": "VAEEncodeForInpaint"
-      },
-      "widgets_values": [
-        6
-      ]
-    },
-    {
-      "id": 19,
-      "type": "Note",
-      "pos": [
-        467.4615173339844,
-        985.1439819335938
-      ],
-      "size": [
-        379.4292297363281,
-        88
-      ],
-      "flags": {},
-      "order": 4,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [],
-      "properties": {},
-      "widgets_values": [
-        "Option 2: UPLOAD THE MASK AS OTHER IMAGE (useful if you require the image that is below the mask to do inpainting, in this case to generate new glasses)"
-      ],
-      "color": "#432",
-      "bgcolor": "#653"
-    },
-    {
-      "id": 22,
-      "type": "ComfyUIDeployExternalImage",
-      "pos": [
-        910.8199462890625,
-        1132.306396484375
-      ],
-      "size": [
-        390.5999755859375,
-        154
-      ],
-      "flags": {},
-      "order": 7,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "default_value",
-          "shape": 7,
-          "type": "IMAGE",
-          "link": 17
-        }
-      ],
-      "outputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "links": [
-            22,
-            23
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfyui-deploy",
-        "ver": "cd3a2ff5471828f9c840e746551592e882c05aa4",
-        "Node name for S&R": "ComfyUIDeployExternalImage"
-      },
-      "widgets_values": [
-        "input_image",
-        "",
-        "",
-        "",
-        ""
-      ]
-    },
-    {
-      "id": 23,
-      "type": "ComfyUIDeployExternalImage",
-      "pos": [
-        843.6348876953125,
-        1467.8876953125
-      ],
-      "size": [
-        390.5999755859375,
-        154
-      ],
-      "flags": {},
-      "order": 6,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "default_value",
-          "shape": 7,
-          "type": "IMAGE",
-          "link": 18
-        }
-      ],
-      "outputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "links": [
-            19
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfyui-deploy",
-        "ver": "cd3a2ff5471828f9c840e746551592e882c05aa4",
-        "Node name for S&R": "ComfyUIDeployExternalImage"
-      },
-      "widgets_values": [
-        "input_image_mask",
-        "",
-        "",
-        "",
-        ""
-      ]
-    },
-    {
-      "id": 12,
-      "type": "ComfyUIDeployExternalImageAlpha",
-      "pos": [
-        1107.891357421875,
-        418.2679138183594
-      ],
-      "size": [
-        466.1999816894531,
-        200
-      ],
-      "flags": {},
-      "order": 8,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "default_value",
-          "shape": 7,
-          "type": "IMAGE",
-          "link": 11
-        }
-      ],
-      "outputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "links": [
-            13
-          ]
-        }
-      ],
-      "properties": {
-        "cnr_id": "comfyui-deploy",
-        "ver": "cd3a2ff5471828f9c840e746551592e882c05aa4",
-        "Node name for S&R": "ComfyUIDeployExternalImageAlpha"
-      },
-      "widgets_values": [
-        "input_image_alpha",
-        "",
-        ""
-      ]
-    }
-  ],
-  "links": [
-    [
-      10,
-      10,
-      0,
-      11,
-      0,
-      "IMAGE"
-    ],
-    [
-      11,
-      11,
-      0,
-      12,
-      0,
-      "IMAGE"
-    ],
-    [
-      12,
-      10,
-      1,
-      11,
-      1,
-      "MASK"
-    ],
-    [
-      13,
-      12,
-      0,
-      13,
-      0,
-      "IMAGE"
-    ],
-    [
-      14,
-      13,
-      0,
-      14,
-      0,
-      "IMAGE"
-    ],
-    [
-      15,
-      13,
-      1,
-      17,
-      0,
-      "MASK"
-    ],
-    [
-      16,
-      17,
-      0,
-      15,
-      0,
-      "IMAGE"
-    ],
-    [
-      17,
-      20,
-      0,
-      22,
-      0,
-      "IMAGE"
-    ],
-    [
-      18,
-      21,
-      0,
-      23,
-      0,
-      "IMAGE"
-    ],
-    [
-      19,
-      23,
-      0,
-      24,
-      0,
-      "IMAGE"
-    ],
-    [
-      21,
-      25,
-      0,
-      26,
-      0,
-      "IMAGE"
-    ],
-    [
-      22,
-      22,
-      0,
-      27,
-      0,
-      "IMAGE"
-    ],
-    [
-      23,
-      22,
-      0,
-      28,
-      0,
-      "IMAGE"
-    ],
-    [
-      24,
-      24,
-      0,
-      28,
-      2,
-      "MASK"
-    ],
-    [
-      25,
-      13,
-      0,
-      29,
-      0,
-      "IMAGE"
-    ],
-    [
-      26,
-      13,
-      1,
-      29,
-      2,
-      "MASK"
-    ],
-    [
-      28,
-      24,
-      0,
-      25,
-      0,
-      "MASK"
-    ]
-  ],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": {
-      "scale": 0.9646149645000013,
-      "offset": [
-        48.66905973637718,
-        -817.5683540167485
-      ]
-    },
-    "VHS_latentpreview": false,
-    "VHS_latentpreviewrate": 0,
-    "VHS_MetadataImage": true,
-    "VHS_KeepIntermediate": true
-  },
-  "version": 0.4
-}

globals.py

@@ -18,7 +18,6 @@ class Status(Enum):
     SUCCESS = "success"
     FAILED = "failed"
     UPLOADING = "uploading"
-    CANCELLED = "cancelled"
 
 
 class StreamingPrompt(BaseModel):

pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "comfyui-deploy"
 description = "Open source comfyui deployment platform, a vercel for generative workflow infra."
-version = "2.3.4"
+version = "2.0.0"
 license = { file = "LICENSE" }
-dependencies = ["aiofiles", "pydantic", "opencv-python", "imageio-ffmpeg", "tabulate", "brotli"]
+dependencies = ["aiofiles", "pydantic", "opencv-python", "imageio-ffmpeg"]
 
 [project.urls]
 Repository = "https://github.com/BennyKok/comfyui-deploy"

web-plugin/snapshot-utils.js

@@ -1,82 +0,0 @@
-// Snapshot Utilities
-// Centralized snapshot fetching with ComfyUI version fallback
-
-/**
- * Fetches the current snapshot with ComfyUI version fallback
- * If the snapshot response has null comfyui field, it will fetch the latest ComfyUI version
- * and update the snapshot with the comfyui_hash
- *
- * @param {Function} getDataFn - Function that returns { apiKey, apiUrl } for ComfyUI version API calls
- * @returns {Promise<Object>} - The snapshot data with comfyui field populated
- */
-export async function fetchSnapshot(getDataFn = null) {
-  try {
-    // Fetch the current snapshot
-    const response = await fetch("/snapshot/get_current");
-    if (!response.ok) {
-      throw new Error(`Snapshot fetch failed: ${response.status}`);
-    }
-
-    const snapshot = await response.json();
-
-    // Check if comfyui field is null and we have getDataFn for fallback
-    if (snapshot.comfyui === null && getDataFn) {
-      console.log(
-        "ComfyUI version is null in snapshot, fetching latest version..."
-      );
-
-      try {
-        const data = getDataFn();
-        if (data && data.apiKey) {
-          const comfyuiVersionResponse = await fetch(
-            `/comfyui-deploy/comfyui-version?api_url=${encodeURIComponent(
-              data.apiUrl || "https://api.comfydeploy.com"
-            )}`,
-            {
-              headers: {
-                Authorization: `Bearer ${data.apiKey}`,
-              },
-            }
-          );
-
-          if (comfyuiVersionResponse.ok) {
-            const versionData = await comfyuiVersionResponse.json();
-            if (versionData.comfyui_hash) {
-              console.log(
-                `Using ComfyUI hash from API: ${versionData.comfyui_hash}`
-              );
-              snapshot.comfyui = versionData.comfyui_hash;
-            }
-          } else {
-            console.warn(
-              "Failed to fetch ComfyUI version from API:",
-              comfyuiVersionResponse.status
-            );
-          }
-        }
-      } catch (error) {
-        console.warn("Error fetching ComfyUI version fallback:", error);
-        // Continue with original snapshot even if fallback fails
-      }
-    }
-
-    return snapshot;
-  } catch (error) {
-    console.error("Error fetching snapshot:", error);
-    throw error;
-  }
-}
-
-/**
- * Simple snapshot fetch without ComfyUI version fallback
- * Use this when you don't need the ComfyUI version fallback logic
- *
- * @returns {Promise<Object>} - The snapshot data as-is
- */
-export async function fetchSnapshotSimple() {
-  const response = await fetch("/snapshot/get_current");
-  if (!response.ok) {
-    throw new Error(`Snapshot fetch failed: ${response.status}`);
-  }
-  return response.json();
-}