Bump version to 2.3.5 in Manager

* init

* tweak

* add: model display

* test

* add: real logic to upload model

* fix native mode

* tweak again

* add: workflow version control

* fix: versioning display

* refactor: remove unnecessary code

README.md

@@ -2,6 +2,8 @@
 
 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)
 

comfy-nodes/external_lora.py

@@ -1,8 +1,4 @@
 import folder_paths
-from PIL import Image, ImageOps
-import numpy as np
-import torch
-import folder_paths
 
 
 class AnyType(str):
@@ -41,6 +37,10 @@ class ComfyUIDeployExternalLora:
                     "STRING",
                     {"multiline": False, "default": ""},
                 ),
+                "bearer_token": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
             },
         }
 
@@ -57,6 +57,7 @@ class ComfyUIDeployExternalLora:
         display_name=None,
         description=None,
         lora_url=None,
+        bearer_token=None,
     ):
         import requests
         import os
@@ -84,9 +85,13 @@ 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={"User-Agent": "Mozilla/5.0"},
+                    headers=headers,
                     allow_redirects=True,
                 )
                 with open(destination_path, "wb") as out_file:

comfy-nodes/external_number_slider_int.py

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

@@ -0,0 +1,116 @@
+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,36 +748,64 @@ 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": ""},
-                    ),
-                },
-                "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": ""},
+                ),
+                "default_value_url": ("STRING", {"image_preview": True, "default": ""}),
+            },
+            "hidden": {"unique_id": "UNIQUE_ID"},
+        }
 
     CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
 
@@ -804,16 +832,21 @@ 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"):
+        if input_id.startswith("http") or (
+            default_value_url and default_value_url.startswith("http")
+        ):
             import requests
 
-            print("Fetching video from URL: ", input_id)
-            response = requests.get(input_id, stream=True)
+            # 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)
             file_size = int(response.headers.get("Content-Length", 0))
-            file_extension = input_id.split(".")[-1].split("?")[
+            file_extension = url.split(".")[-1].split("?")[
                 0
             ]  # Extract extension and handle URLs with parameters
             if file_extension not in video_extensions:

comfy-nodes/output_exr.py

@@ -0,0 +1,78 @@
+# 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)"}

globals.py

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

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-deploy"
 description = "Open source comfyui deployment platform, a vercel for generative workflow infra."
-version = "2.1.0"
+version = "2.3.5"
 license = { file = "LICENSE" }
 dependencies = ["aiofiles", "pydantic", "opencv-python", "imageio-ffmpeg", "tabulate", "brotli"]
 

web-plugin/snapshot-utils.js

@@ -0,0 +1,82 @@
+// 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();
+}