fix: max_retries and retry_delay_multiplier, do not throw when pass the retry failed

* feat: add streaming endpoint

* fix: run issues

* feat(plugin): add dispatchAPIEventData

* fix(plugin): event

* fix: streaming event format

* fix: prompt error

* fix: node_error proxy

* chore(plugin): add log

* custom route

---------

Co-authored-by: nick <[email protected]>

.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

comfy-nodes/external_boolean.py

@@ -0,0 +1,25 @@
+class ComfyUIDeployExternalBoolean:
+    @classmethod    
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_bool"},
+                ),
+                "default_value": ("BOOLEAN", {"default": False})
+            }
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    RETURN_NAMES = ("bool_value",)
+    
+    FUNCTION = "run"
+    
+    def run(self, input_id, default_value=None):
+        print(f"Node '{input_id}' processing with switch set to {default_value}")
+        return [default_value]
+    
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalBoolean": ComfyUIDeployExternalBoolean}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalBoolean": "External Boolean (ComfyUI Deploy)"}

comfy-nodes/external_checkpoints.py

@@ -5,6 +5,12 @@ import torch
 import folder_paths
 from tqdm import tqdm
 
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+        
+WILDCARD = AnyType("*")
+
 class ComfyUIDeployExternalCheckpoint:
     @classmethod
     def INPUT_TYPES(s):
@@ -20,7 +26,7 @@ class ComfyUIDeployExternalCheckpoint:
             }
         }
 
-    RETURN_TYPES = (folder_paths.get_filename_list("checkpoints"),)
+    RETURN_TYPES = (WILDCARD,)
     RETURN_NAMES = ("path",)
 
     FUNCTION = "run"

comfy-nodes/external_image_batch.py

@@ -0,0 +1,85 @@
+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",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "image"
+    
+    def run(self, input_id, images=None, default_value=None):
+        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'):
+                    import requests
+                    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

@@ -4,6 +4,11 @@ import numpy as np
 import torch
 import folder_paths
 
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+        
+WILDCARD = AnyType("*")
 
 class ComfyUIDeployExternalLora:
     @classmethod
@@ -16,11 +21,11 @@ class ComfyUIDeployExternalLora:
                 ),
             },
             "optional": {
-                "default_lora_name": (folder_paths.get_filename_list("loras"), ),
+                "default_lora_name": (folder_paths.get_filename_list("loras"),),
-            }
+            },
         }
 
-    RETURN_TYPES = (folder_paths.get_filename_list("loras"),)
+    RETURN_TYPES = (WILDCARD,)
     RETURN_NAMES = ("path",)
 
     FUNCTION = "run"
@@ -32,20 +37,29 @@ class ComfyUIDeployExternalLora:
         import os
         import uuid
 
-        if input_id and input_id.startswith('http'):
+        if default_lora_name.startswith("http"):
             unique_filename = str(uuid.uuid4()) + ".safetensors"
             print(unique_filename)
             print(folder_paths.folder_names_and_paths["loras"][0][0])
-            destination_path = os.path.join(folder_paths.folder_names_and_paths["loras"][0][0], unique_filename)
+            destination_path = os.path.join(
+                folder_paths.folder_names_and_paths["loras"][0][0], unique_filename
+            )
             print(destination_path)
             print("Downloading external lora - " + input_id + " to " + destination_path)
-            response = requests.get(input_id, headers={'User-Agent': 'Mozilla/5.0'}, allow_redirects=True)
+            response = requests.get(
-            with open(destination_path, 'wb') as out_file:
+                input_id,
+                headers={"User-Agent": "Mozilla/5.0"},
+                allow_redirects=True,
+            )
+            with open(destination_path, "wb") as out_file:
                 out_file.write(response.content)
             return (unique_filename,)
         else:
+            print(f"using lora: {default_lora_name}")
             return (default_lora_name,)
 
 
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalLora": ComfyUIDeployExternalLora}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalLora": "External Lora (ComfyUI Deploy)"}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalLora": "External Lora (ComfyUI Deploy)"
+}

comfy-nodes/external_number_int.py

@@ -29,7 +29,7 @@ class ComfyUIDeployExternalNumberInt:
     CATEGORY = "number"
 
     def run(self, input_id, default_value=None):
-        if not input_id or not input_id.strip().isdigit():
+        if not input_id or (isinstance(input_id, str) and not input_id.strip().isdigit()):
             return [default_value]
         return [int(input_id)]
 

comfy-nodes/external_number_slider.py

@@ -0,0 +1,48 @@
+class ComfyUIDeployExternalNumberSlider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_number_slider"},
+                ),
+            },
+            "optional": {
+                "default_value": (
+                    "FLOAT",
+                    {"multiline": True, "display": "number", "default": 0.5, "step": 0.01},
+                ),
+                "min_value": (
+                    "FLOAT",
+                    {"multiline": True, "display": "number", "default": 0, "step": 0.01},
+                ),
+                "max_value": (
+                    "FLOAT",
+                    {"multiline": True, "display": "number", "default": 1, "step": 0.01},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    RETURN_NAMES = ("value",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "number"
+
+    def run(self, input_id, default_value=None, min_value=0, max_value=1):
+        try:
+            float_value = float(input_id)
+            if min_value <= float_value <= max_value:
+                print("my number", float_value)
+                return [float_value]
+            else:
+                print("Number out of range. Returning default value:", default_value)
+                return [default_value]
+        except ValueError:
+            print("Invalid input. Returning default value:", default_value)
+            return [default_value]
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalNumberSlider": ComfyUIDeployExternalNumberSlider}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalNumberSlider": "External Number Slider (ComfyUI Deploy)"}

comfy-nodes/external_vid.py

@@ -0,0 +1,78 @@
+import os
+import folder_paths
+import uuid
+
+from tqdm import tqdm
+
+video_extensions = ["webm", "mp4", "mkv", "gif"]
+
+
+class ComfyUIDeployExternalVideo:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        files = []
+        for f in os.listdir(input_dir):
+            if os.path.isfile(os.path.join(input_dir, f)):
+                file_parts = f.split(".")
+                if len(file_parts) > 1 and (file_parts[-1] in video_extensions):
+                    files.append(f)
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_video"},
+                ),
+            },
+            "optional": {
+                "meta_batch": ("VHS_BatchManager",),
+                "default_value": (sorted(files),),
+            },
+        }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("video")
+
+    FUNCTION = "load_video"
+
+    def load_video(self, input_id, default_value):
+        input_dir = folder_paths.get_input_directory()
+        if input_id.startswith("http"):
+            import requests
+
+            print("Fetching video from URL: ", input_id)
+            response = requests.get(input_id, stream=True)
+            file_size = int(response.headers.get("Content-Length", 0))
+            file_extension = input_id.split(".")[-1].split("?")[
+                0
+            ]  # Extract extension and handle URLs with parameters
+            if file_extension not in video_extensions:
+                file_extension = ".mp4"
+
+            unique_filename = str(uuid.uuid4()) + "." + file_extension
+            video_path = os.path.join(input_dir, unique_filename)
+            chunk_size = 1024  # 1 Kibibyte
+
+            num_bars = int(file_size / chunk_size)
+
+            with open(video_path, "wb") as out_file:
+                for chunk in tqdm(
+                    response.iter_content(chunk_size=chunk_size),
+                    total=num_bars,
+                    unit="KB",
+                    desc="Downloading",
+                    leave=True,
+                ):
+                    out_file.write(chunk)
+        else:
+            video_path = os.path.abspath(os.path.join(input_dir, default_value))
+
+        return (video_path,)
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalVid": ComfyUIDeployExternalVideo}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalVid": "External Video (ComfyUI Deploy) path"
+}

comfy-nodes/external_video.py

@@ -0,0 +1,855 @@
+# 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_value": (sorted(files),),
+                },
+                "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")
+
+        video = kwargs.get("default_value")
+        video_path = folder_paths.get_annotated_filepath(video.strip('"'))
+
+        input_dir = folder_paths.get_input_directory()
+        if input_id.startswith("http"):
+            import requests
+
+            print("Fetching video from URL: ", input_id)
+            response = requests.get(input_id, stream=True)
+            file_size = int(response.headers.get("Content-Length", 0))
+            file_extension = input_id.split(".")[-1].split("?")[
+                0
+            ]  # Extract extension and handle URLs with parameters
+            if file_extension not in video_extensions:
+                file_extension = ".mp4"
+
+            unique_filename = str(uuid.uuid4()) + "." + file_extension
+            video_path = os.path.join(input_dir, unique_filename)
+            chunk_size = 1024  # 1 Kibibyte
+
+            num_bars = int(file_size / chunk_size)
+
+            with open(video_path, "wb") as out_file:
+                for chunk in tqdm(
+                    response.iter_content(chunk_size=chunk_size),
+                    total=num_bars,
+                    unit="KB",
+                    desc="Downloading",
+                    leave=True,
+                ):
+                    out_file.write(chunk)
+
+        print("video path: ", video_path)
+
+        return load_video_cv(
+            video=video_path,
+            force_rate=force_rate,
+            force_size=force_size,
+            custom_width=custom_width,
+            custom_height=custom_height,
+            frame_load_cap=frame_load_cap,
+            skip_first_frames=skip_first_frames,
+            select_every_nth=select_every_nth,
+            meta_batch=meta_batch,
+            unique_id=unique_id,
+        )
+
+    @classmethod
+    def IS_CHANGED(s, video, **kwargs):
+        image_path = folder_paths.get_annotated_filepath(video)
+        return calculate_file_hash(image_path)
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalVideo": ComfyUIDeployExternalVideo}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalVideo": "External Video (ComfyUI Deploy x VHS)"
+}

globals.py

@@ -1,26 +1,45 @@
 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: str
+    status_endpoint: Optional[str]
-    file_upload_endpoint: str
+    file_upload_endpoint: Optional[str]
+    
+class SimplePrompt(BaseModel):
+    status_endpoint: Optional[str]
+    file_upload_endpoint: 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,
 
 sockets = dict()
+prompt_metadata: dict[str, SimplePrompt] = {}
 streaming_prompt_metadata: dict[str, StreamingPrompt] = {}
 
 class BinaryEventTypes:

prestartup_script.py

@@ -58,6 +58,9 @@ 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__))
@@ -67,3 +70,6 @@ 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

@@ -0,0 +1,15 @@
+[project]
+name = "comfyui-deploy"
+description = "Open source comfyui deployment platform, a vercel for generative workflow infra."
+version = "1.0.0"
+license = "LICENSE"
+dependencies = ["aiofiles", "pydantic", "opencv-python", "imageio-ffmpeg"]
+
+[project.urls]
+Repository = "https://github.com/BennyKok/comfyui-deploy"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "comfydeploy"
+DisplayName = "comfyui-deploy"
+Icon = ""

requirements.txt

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

web-plugin/index.js

@@ -1,10 +1,87 @@
 import { app } from "./app.js";
 import { api } from "./api.js";
 import { ComfyWidgets, LGraphNode } from "./widgets.js";
-import { generateDependencyGraph } from "https://esm.sh/[email protected]2";
+import { generateDependencyGraph } from "https://esm.sh/[email protected]5";
 
 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 = {
@@ -18,6 +95,34 @@ 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;
@@ -152,10 +257,57 @@ const ext = {
   async setup() {
     // const graphCanvas = document.getElementById("graph-canvas");
 
-    window.addEventListener("message", (event) => {
+    window.addEventListener("message", async (event) => {
-      if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
+      //   console.log("message", event);
-        return;
+      try {
-      //   updateBlendshapesPrompts(event.data.flow);
+        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();
+          api.handlePromptGenerated(prompt);
+          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 === "refresh") {
+        //   sendEventToCD("cd_plugin_onRefresh");
+        // }
+      } catch (error) {
+        // console.error("Error processing message:", error);
+      }
     });
 
     api.addEventListener("executed", (evt) => {
@@ -167,6 +319,18 @@ 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");
   },
 };
 
@@ -200,10 +364,10 @@ function createDynamicUIHtml(data) {
           <h3 style="font-size: 14px; font-weight: semibold; margin-bottom: 8px;">Missing Nodes</h3>
           <p style="font-size: 12px;">These nodes are not found with any matching custom_nodes in the ComfyUI Manager Database</p>
           ${data.missing_nodes
-            .map((node) => {
+        .map((node) => {
-              return `<p style="font-size: 14px; color: #d69e2e;">${node}</p>`;
+          return `<p style="font-size: 14px; color: #d69e2e;">${node}</p>`;
-            })
+        })
-            .join("")}
+        .join("")}
       </div>
   `;
   }
@@ -211,17 +375,14 @@ function createDynamicUIHtml(data) {
   Object.values(data.custom_nodes).forEach((node) => {
     html += `
           <div style="border-bottom: 1px solid #e2e8f0; padding-top: 16px;">
-              <a href="${
+              <a href="${node.url
-                node.url
+      }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${node.name
-              }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${
+      }</a>
-                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>`
-                  ? `<p style="font-size: 14px; color: #d69e2e;">${node.warning}</p>`
+        : ""
-                  : ""
+      }
-              }
           </div>
       `;
   });
@@ -235,9 +396,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;">${
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
-          section.charAt(0).toUpperCase() + section.slice(1)
+      }</h3>`;
-        }</h3>`;
     items.forEach((item) => {
       html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
     });
@@ -253,9 +413,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;">${
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
-          section.charAt(0).toUpperCase() + section.slice(1)
+      }</h3>`;
-        }</h3>`;
     items.forEach((item) => {
       html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
     });
@@ -267,294 +426,296 @@ function createDynamicUIHtml(data) {
   return html;
 }
 
-function addButton() {
+async function deployWorkflow() {
-  const menu = document.querySelector(".comfy-menu");
+  const deploy = document.getElementById("deploy-button");
 
-  const deploy = document.createElement("button");
+  /** @type {LGraph} */
-  deploy.style.position = "relative";
+  const graph = app.graph;
-  deploy.style.display = "block";
-  deploy.innerHTML = "<div id='button-title'>Deploy</div>";
-  deploy.onclick = async () => {
-    /** @type {LGraph} */
-    const graph = app.graph;
 
-    let { endpoint, apiKey, displayName } = getData();
+  let { endpoint, apiKey, displayName } = getData();
 
-    if (!endpoint || !apiKey || apiKey === "" || endpoint === "") {
+  if (!endpoint || !apiKey || apiKey === "" || endpoint === "") {
-      configDialog.show();
+    configDialog.show();
-      return;
+    return;
-    }
+  }
 
-    let deployMeta = graph.findNodesByType("ComfyDeploy");
+  let deployMeta = graph.findNodesByType("ComfyDeploy");
 
-    if (deployMeta.length == 0) {
+  if (deployMeta.length == 0) {
-      const text = await inputDialog.input(
+    const text = await inputDialog.input(
-        "Create your deployment",
+      "Create your deployment",
-        "Workflow name",
+      "Workflow name",
-      );
-      if (!text) return;
-      console.log(text);
-      app.graph.beforeChange();
-      var node = LiteGraph.createNode("ComfyDeploy");
-      node.configure({
-        widgets_values: [text],
-      });
-      node.pos = [0, 0];
-      app.graph.add(node);
-      app.graph.afterChange();
-      deployMeta = [node];
-    }
-
-    const deployMetaNode = deployMeta[0];
-
-    const workflow_name = deployMetaNode.widgets[0].value;
-    const workflow_id = deployMetaNode.widgets[1].value;
-
-    const ok = await confirmDialog.confirm(
-      `Confirm deployment`,
-      `
-      <div>
-
-      A new version of <button style="font-size: 18px;">${workflow_name}</button> will be deployed, do you confirm? 
-      <br><br>
-
-      <button style="font-size: 18px;">${displayName}</button>
-      <br>
-      <button style="font-size: 18px;">${endpoint}</button>
-
-      <br><br>
-      <label>
-      <input id="include-deps" type="checkbox" checked>Include dependency</input>
-      </label>
-      <br>
-      <label>
-      <input id="reuse-hash" type="checkbox" checked>Reuse hash from last version</input>
-      </label>
-      </div>
-      `,
     );
-    if (!ok) return;
+    if (!text) return;
+    console.log(text);
+    app.graph.beforeChange();
+    var node = LiteGraph.createNode("ComfyDeploy");
+    node.configure({
+      widgets_values: [text],
+    });
+    node.pos = [0, 0];
+    app.graph.add(node);
+    app.graph.afterChange();
+    deployMeta = [node];
+  }
 
-    const includeDeps = document.getElementById("include-deps").checked;
+  const deployMetaNode = deployMeta[0];
-    const reuseHash = document.getElementById("reuse-hash").checked;
 
-    if (endpoint.endsWith("/")) {
+  const workflow_name = deployMetaNode.widgets[0].value;
-      endpoint = endpoint.slice(0, -1);
+  const workflow_id = deployMetaNode.widgets[1].value;
-    }
-    loadingDialog.showLoading("Generating snapshot");
 
-    const snapshot = await fetch("/snapshot/get_current").then((x) => x.json());
+  const ok = await confirmDialog.confirm(
-    // console.log(snapshot);
+    `Confirm deployment`,
-    loadingDialog.close();
+    `
+    <div>
 
-    if (!snapshot) {
+    A new version of <button style="font-size: 18px;">${workflow_name}</button> will be deployed, do you confirm? 
-      showError(
+    <br><br>
-        "Error when deploying",
-        "Unable to generate snapshot, please install ComfyUI Manager",
-      );
-      return;
-    }
 
-    const title = deploy.querySelector("#button-title");
+    <button style="font-size: 18px;">${displayName}</button>
+    <br>
+    <button style="font-size: 18px;">${endpoint}</button>
 
-    const prompt = await app.graphToPrompt();
+    <br><br>
-    let deps = undefined;
+    <label>
+    <input id="include-deps" type="checkbox" checked>Include dependency</input>
+    </label>
+    <br>
+    <label>
+    <input id="reuse-hash" type="checkbox" checked>Reuse hash from last version</input>
+    </label>
+    </div>
+    `,
+  );
+  if (!ok) return;
 
-    if (includeDeps) {
+  const includeDeps = document.getElementById("include-deps").checked;
-      loadingDialog.showLoading("Fetching existing version");
+  const reuseHash = document.getElementById("reuse-hash").checked;
 
-      const existing_workflow = await fetch(
+  if (endpoint.endsWith("/")) {
-        endpoint + "/api/workflow/" + workflow_id,
+    endpoint = endpoint.slice(0, -1);
-        {
+  }
-          method: "GET",
+  loadingDialog.showLoading("Generating snapshot");
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: "Bearer " + apiKey,
-          },
-        },
-      )
-        .then((x) => x.json())
-        .catch(() => {
-          return {};
-        });
 
-      loadingDialog.close();
+  const snapshot = await fetch("/snapshot/get_current").then((x) => x.json());
+  // console.log(snapshot);
+  loadingDialog.close();
 
-      loadingDialog.showLoading("Generating dependency graph");
+  if (!snapshot) {
-      deps = await generateDependencyGraph({
+    showError(
-        workflow_api: prompt.output,
+      "Error when deploying",
-        snapshot: snapshot,
+      "Unable to generate snapshot, please install ComfyUI Manager",
-        computeFileHash: async (file) => {
+    );
-          console.log(existing_workflow?.dependencies?.models);
+    return;
+  }
 
-          // Match previous hash for models
+  const title = deploy.querySelector("#button-title");
-          if (reuseHash && existing_workflow?.dependencies?.models) {
-            const previousModelHash = Object.entries(
-              existing_workflow?.dependencies?.models,
-            ).flatMap(([key, value]) => {
-              return Object.values(value).map((x) => ({
-                ...x,
-                name: "models/" + key + "/" + x.name,
-              }));
-            });
-            console.log(previousModelHash);
 
-            const match = previousModelHash.find((x) => {
+  const prompt = await app.graphToPrompt();
-              console.log(file, x.name);
+  let deps = undefined;
-              return file == x.name;
-            });
-            console.log(match);
-            if (match && match.hash) {
-              console.log("cached hash used");
-              return match.hash;
-            }
-          }
-          console.log(file);
-          loadingDialog.showLoading("Generating hash", file);
-          const hash = await fetch(
-            `/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;
-          }
-        },
-        existingDependencies: existing_workflow.dependencies,
-      });
 
-      // Need to find a way to include this if this is not included in comfyui-json level
+  if (includeDeps) {
-      if (
+    loadingDialog.showLoading("Fetching existing version");
-        !deps.custom_nodes["https://github.com/BennyKok/comfyui-deploy"] &&
-        !deps.custom_nodes["https://github.com/BennyKok/comfyui-deploy.git"]
-      )
-        deps.custom_nodes["https://github.com/BennyKok/comfyui-deploy"] = {
-          url: "https://github.com/BennyKok/comfyui-deploy",
-          install_type: "git-clone",
-          hash:
-            snapshot?.git_custom_nodes?.[
-              "https://github.com/BennyKok/comfyui-deploy"
-            ]?.hash ?? "HEAD",
-          name: "ComfyUI Deploy",
-        };
 
-      loadingDialog.close();
+    const existing_workflow = await fetch(
-
+      endpoint + "/api/workflow/" + workflow_id,
-      const depsOk = await confirmDialog.confirm(
+      {
-        "Check dependencies",
+        method: "GET",
-        // JSON.stringify(deps, null, 2),
-        `
-        <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;"
-        src="https://www.comfydeploy.com/dependency-graph?deps=${encodeURIComponent(
-          JSON.stringify(deps),
-        )}" />`,
-        // createDynamicUIHtml(deps),
-      );
-      if (!depsOk) return;
-
-      console.log(deps);
-    }
-
-    loadingDialog.showLoading("Deploying...");
-
-    title.innerText = "Deploying...";
-    title.style.color = "orange";
-
-    // console.log(prompt);
-
-    // TODO trim the ending / from endpoint is there is
-    if (endpoint.endsWith("/")) {
-      endpoint = endpoint.slice(0, -1);
-    }
-
-    // console.log(prompt.workflow);
-
-    const apiRoute = endpoint + "/api/workflow";
-    // const userId = apiKey
-    try {
-      const body = {
-        workflow_name,
-        workflow_id,
-        workflow: prompt.workflow,
-        workflow_api: prompt.output,
-        snapshot: snapshot,
-        dependencies: deps,
-      };
-      console.log(body);
-      let data = await fetch(apiRoute, {
-        method: "POST",
-        body: JSON.stringify(body),
         headers: {
           "Content-Type": "application/json",
           Authorization: "Bearer " + apiKey,
         },
+      },
+    )
+      .then((x) => x.json())
+      .catch(() => {
+        return {};
       });
 
-      console.log(data);
+    loadingDialog.close();
 
-      if (data.status !== 200) {
+    loadingDialog.showLoading("Generating dependency graph");
-        throw new Error(await data.text());
+    deps = await generateDependencyGraph({
-      } else {
+      workflow_api: prompt.output,
-        data = await data.json();
+      snapshot: snapshot,
-      }
+      computeFileHash: async (file) => {
+        console.log(existing_workflow?.dependencies?.models);
 
-      loadingDialog.close();
+        // Match previous hash for models
+        if (reuseHash && existing_workflow?.dependencies?.models) {
+          const previousModelHash = Object.entries(
+            existing_workflow?.dependencies?.models,
+          ).flatMap(([key, value]) => {
+            return Object.values(value).map((x) => ({
+              ...x,
+              name: "models/" + key + "/" + x.name,
+            }));
+          });
+          console.log(previousModelHash);
 
-      title.textContent = "Done";
+          const match = previousModelHash.find((x) => {
-      title.style.color = "green";
+            console.log(file, x.name);
+            return file == x.name;
+          });
+          console.log(match);
+          if (match && match.hash) {
+            console.log("cached hash used");
+            return match.hash;
+          }
+        }
+        console.log(file);
+        loadingDialog.showLoading("Generating hash", file);
+        const hash = await fetch(
+          `/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;
+        }
+      },
+      existingDependencies: existing_workflow.dependencies,
+    });
 
-      deployMetaNode.widgets[1].value = data.workflow_id;
+    // Need to find a way to include this if this is not included in comfyui-json level
-      deployMetaNode.widgets[2].value = data.version;
+    if (
-      graph.change();
+      !deps.custom_nodes["https://github.com/BennyKok/comfyui-deploy"] &&
+      !deps.custom_nodes["https://github.com/BennyKok/comfyui-deploy.git"]
+    )
+      deps.custom_nodes["https://github.com/BennyKok/comfyui-deploy"] = {
+        url: "https://github.com/BennyKok/comfyui-deploy",
+        install_type: "git-clone",
+        hash:
+          snapshot?.git_custom_nodes?.[
+            "https://github.com/BennyKok/comfyui-deploy"
+          ]?.hash ?? "HEAD",
+        name: "ComfyUI Deploy",
+      };
 
-      infoDialog.show(
+    loadingDialog.close();
-        `<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/>`,
-      );
 
-      setTimeout(() => {
+    const depsOk = await confirmDialog.confirm(
-        title.textContent = "Deploy";
+      "Check dependencies",
-        title.style.color = "white";
+      // JSON.stringify(deps, null, 2),
-      }, 1000);
+      `
-    } catch (e) {
+      <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);">${loadingIcon}</div>
-      loadingDialog.close();
+      <iframe 
-      app.ui.dialog.show(e);
+      style="z-index: 10; min-width: 600px; max-width: 1024px; min-height: 600px; border: none; background-color: transparent;"
-      console.error(e);
+      src="https://www.comfydeploy.com/dependency-graph?deps=${encodeURIComponent(
-      title.textContent = "Error";
+        JSON.stringify(deps),
-      title.style.color = "red";
+      )}" />`,
-      setTimeout(() => {
+      // createDynamicUIHtml(deps),
-        title.textContent = "Deploy";
+    );
-        title.style.color = "white";
+    if (!depsOk) return;
-      }, 1000);
+
+    console.log(deps);
+  }
+
+  loadingDialog.showLoading("Deploying...");
+
+  title.innerText = "Deploying...";
+  title.style.color = "orange";
+
+  // console.log(prompt);
+
+  // TODO trim the ending / from endpoint is there is
+  if (endpoint.endsWith("/")) {
+    endpoint = endpoint.slice(0, -1);
+  }
+
+  // console.log(prompt.workflow);
+
+  const apiRoute = endpoint + "/api/workflow";
+  // const userId = apiKey
+  try {
+    const body = {
+      workflow_name,
+      workflow_id,
+      workflow: prompt.workflow,
+      workflow_api: prompt.output,
+      snapshot: snapshot,
+      dependencies: deps,
+    };
+    console.log(body);
+    let data = await fetch(apiRoute, {
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + apiKey,
+      },
+    });
+
+    console.log(data);
+
+    if (data.status !== 200) {
+      throw new Error(await data.text());
+    } else {
+      data = await data.json();
     }
+
+    loadingDialog.close();
+
+    title.textContent = "Done";
+    title.style.color = "green";
+
+    deployMetaNode.widgets[1].value = data.workflow_id;
+    deployMetaNode.widgets[2].value = data.version;
+    graph.change();
+
+    infoDialog.show(
+      `<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/>`,
+    );
+
+    setTimeout(() => {
+      title.textContent = "Deploy";
+      title.style.color = "white";
+    }, 1000);
+  } catch (e) {
+    loadingDialog.close();
+    app.ui.dialog.show(e);
+    console.error(e);
+    title.textContent = "Error";
+    title.style.color = "red";
+    setTimeout(() => {
+      title.textContent = "Deploy";
+      title.style.color = "white";
+    }, 1000);
+  }
+}
+
+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");
@@ -676,14 +837,12 @@ 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} ${
+        <h3 style="margin: 0px; display: flex; align-items: center; justify-content: center; gap: 12px;">${title} ${this.loadingIcon
-          this.loadingIcon
+      }</h3>
-        }</h3>
+          ${message
-          ${
+        ? `<label style="max-width: 100%; white-space: pre-wrap; word-wrap: break-word;">${message}</label>`
-            message
+        : ""
-              ? `<label style="max-width: 100%; white-space: pre-wrap; word-wrap: break-word;">${message}</label>`
+      }
-              : ""
-          }
         </div>
       `);
   }
@@ -949,21 +1108,17 @@ 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="${
+        <input id="endpoint" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="text" value="${data.endpoint
-          data.endpoint
+      }">
-        }">
       </label>
       <div style="color: white;">
-        API Key: User / Org <button style="font-size: 18px;">${
+        API Key: User / Org <button style="font-size: 18px;">${data.displayName ?? ""
-          data.displayName ?? ""
+      }</button>
-        }</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>
       </div>

web/package.json

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

web/src/server/createRun.ts

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