Update Dockerfile

adding Postgres port env var

.github/workflows/publish.yml

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

comfy-nodes/external_boolean.py

@@ -1,25 +0,0 @@
-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_image_batch.py

@@ -1,85 +0,0 @@
-import folder_paths
-from PIL import Image, ImageOps
-import numpy as np
-import torch
-import json
-import comfy
-
-class ComfyUIDeployExternalImageBatch:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": "input_images"},
-                ),
-                "images": (
-                    "STRING",
-                    {"multiline": False, "default": "[]"},
-                ),
-            },
-            "optional": {
-                "default_value": ("IMAGE",),
-            }
-        }
-
-    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

@@ -16,8 +16,8 @@ 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"),)
@@ -32,29 +32,20 @@ class ComfyUIDeployExternalLora:
         import os
         import uuid
 
-        if default_lora_name.startswith("http"):
+        if input_id and input_id.startswith('http'):
             unique_filename = str(uuid.uuid4()) + ".safetensors"
             print(unique_filename)
             print(folder_paths.folder_names_and_paths["loras"][0][0])
-            destination_path = os.path.join(
-                folder_paths.folder_names_and_paths["loras"][0][0], 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,
-            )
-            with open(destination_path, "wb") as out_file:
+            response = requests.get(input_id, headers={'User-Agent': 'Mozilla/5.0'}, allow_redirects=True)
+            with open(destination_path, 'wb') as out_file:
                 out_file.write(response.content)
             return (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 (isinstance(input_id, str) and not input_id.strip().isdigit()):
+        if not input_id or not input_id.strip().isdigit():
             return [default_value]
         return [int(input_id)]
 

comfy-nodes/external_number_slider.py

@@ -1,48 +0,0 @@
-class ComfyUIDeployExternalNumberSlider:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": "input_number_slider"},
-                ),
-            },
-            "optional": {
-                "default_value": (
-                    "FLOAT",
-                    {"multiline": True, "display": "number", "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

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

comfy-nodes/external_video.py

@@ -1,594 +0,0 @@
-# credit goes to https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite and is meant to work with
-import os
-import itertools
-import numpy as np
-import torch
-import cv2
-
-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 get_sorted_dir_files_from_directory(
-    directory: str,
-    skip_first_images: int = 0,
-    select_every_nth: int = 1,
-    extensions: Iterable = None,
-):
-    directory = directory.strip()
-    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, "-v", "error", "-i", file]
-    if start_time > 0:
-        args += ["-ss", str(start_time)]
-    if duration > 0:
-        args += ["-t", str(duration)]
-    try:
-        res = subprocess.run(
-            args + ["-f", "wav", "-"], stdout=subprocess.PIPE, check=True
-        ).stdout
-    except subprocess.CalledProcessError as e:
-        return False
-    return res
-
-
-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 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 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(video)
-    if not video_cap.isOpened():
-        raise ValueError(f"{video} could not be loaded with cv.")
-
-    # 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)
-
-    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) / 255.0
-        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 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 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,
-):
-    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,
-            )
-
-    else:
-        (gen, width, height, fps, duration, total_frames, target_frame_time) = (
-            meta_batch.inputs[unique_id]
-        )
-
-    if meta_batch is not None:
-        gen = itertools.islice(gen, meta_batch.frames_per_batch)
-
-    # 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, (height, width, 3))))
-    )
-    if len(images) == 0:
-        raise RuntimeError("No frames generated")
-    if force_size != "Disabled":
-        new_size = target_size(width, height, force_size, custom_width, custom_height)
-        if new_size[0] != width or new_size[1] != height:
-            s = images.movedim(-1, 1)
-            s = common_upscale(s, new_size[0], new_size[1], "lanczos", "center")
-            images = s.movedim(1, -1)
-
-    # Setup lambda for lazy audio capture
-    audio = lambda: get_audio(
-        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": images.shape[2],
-        "loaded_height": images.shape[1],
-    }
-
-    return (images, len(images), lazy_eval(audio), video_info)
-
-
-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",),
-                "default_value": (sorted(files),),
-            },
-            "hidden": {"unique_id": "UNIQUE_ID"},
-        }
-
-    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
-
-    RETURN_TYPES = (
-        "IMAGE",
-        "INT",
-        "VHS_AUDIO",
-        "VHS_VIDEOINFO",
-    )
-    RETURN_NAMES = (
-        "IMAGE",
-        "frame_count",
-        "audio",
-        "video_info",
-    )
-
-    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)"
-}

custom_routes.py

@@ -13,6 +13,7 @@ import traceback
 import uuid
 import asyncio
 import logging
+from enum import Enum
 from urllib.parse import quote
 import threading
 import hashlib
@@ -23,17 +24,32 @@ from PIL import Image
 import copy
 import struct
 
-from globals import StreamingPrompt, Status, sockets, SimplePrompt, streaming_prompt_metadata, prompt_metadata
+from globals import StreamingPrompt, sockets, streaming_prompt_metadata, BaseModel
+
+class Status(Enum):
+    NOT_STARTED = "not-started"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    UPLOADING = "uploading"
+    
+class SimplePrompt(BaseModel):
+    status_endpoint: str
+    file_upload_endpoint: 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,
 
 api = None
 api_task = None
-
+prompt_metadata: dict[str, SimplePrompt] = {}
 cd_enable_log = os.environ.get('CD_ENABLE_LOG', 'false').lower() == 'true'
 cd_enable_run_log = os.environ.get('CD_ENABLE_RUN_LOG', 'false').lower() == 'true'
-bypass_upload = os.environ.get('CD_BYPASS_UPLOAD', 'false').lower() == 'true'
-
-print("CD_BYPASS_UPLOAD", bypass_upload)
-
 
 def clear_current_prompt(sid):
     prompt_server = server.PromptServer.instance
@@ -109,47 +125,6 @@ def apply_random_seed_to_workflow(workflow_api):
                 workflow_api[key]['inputs']['seed'] = randomSeed(8);
                 continue
             workflow_api[key]['inputs']['seed'] = randomSeed();
-            
-def apply_inputs_to_workflow(workflow_api: Any, inputs: Any, sid: str = None):
-    # Loop through each of the inputs and replace them
-    for key, value in workflow_api.items():
-        if 'inputs' in value:
-            
-            # Support websocket
-            if sid is not None:
-                if (value["class_type"] == "ComfyDeployWebscoketImageOutput"):
-                    value['inputs']["client_id"] = sid
-                if (value["class_type"] == "ComfyDeployWebscoketImageInput"):
-                    value['inputs']["client_id"] = sid
-                    
-            if "input_id" in value['inputs'] and inputs is not None and value['inputs']['input_id'] in inputs:
-                new_value = inputs[value['inputs']['input_id']]
-                
-                # Lets skip it if its an image
-                if isinstance(new_value, Image.Image):
-                    continue
-                
-                # Backward compactibility
-                value['inputs']["input_id"] = new_value
-            
-                # Fix for external text default value
-                if (value["class_type"] == "ComfyUIDeployExternalText"):
-                    value['inputs']["default_value"] = new_value
-                    
-                if (value["class_type"] == "ComfyUIDeployExternalCheckpoint"):
-                    value['inputs']["default_value"] = new_value
-                    
-                if (value["class_type"] == "ComfyUIDeployExternalImageBatch"):
-                    value['inputs']["images"] = new_value
-                
-                if value["class_type"] == "ComfyUIDeployExternalLora":
-                    value["inputs"]["default_lora_name"] = new_value
-                
-                if value["class_type"] == "ComfyUIDeployExternalSlider":
-                    value["inputs"]["default_value"] = new_value
-                    
-                if value["class_type"] == "ComfyUIDeployExternalBoolean":
-                    value["inputs"]["default_value"] = new_value
 
 def send_prompt(sid: str, inputs: StreamingPrompt):
     # workflow_api = inputs.workflow_api
@@ -159,8 +134,31 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
     apply_random_seed_to_workflow(workflow_api)
             
     print("getting inputs" , inputs.inputs)
-    
-    apply_inputs_to_workflow(workflow_api, inputs.inputs, sid=sid)
+            
+    # Loop through each of the inputs and replace them
+    for key, value in workflow_api.items():
+        if 'inputs' in value:
+            if (value["class_type"] == "ComfyDeployWebscoketImageOutput"):
+                value['inputs']["client_id"] = sid
+            if (value["class_type"] == "ComfyDeployWebscoketImageInput"):
+                value['inputs']["client_id"] = sid
+                
+            if "input_id" in value['inputs'] and value['inputs']['input_id'] in inputs.inputs:
+                new_value = inputs.inputs[value['inputs']['input_id']]
+                
+                # Lets skip it if its an image
+                if isinstance(new_value, Image.Image):
+                    continue
+                
+                value['inputs']["input_id"] = new_value
+            
+                # Fix for external text default value
+                if (value["class_type"] == "ComfyUIDeployExternalText"):
+                    value['inputs']["default_value"] = new_value
+                    
+                if (value["class_type"] == "ComfyUIDeployExternalCheckpoint"):
+                    value['inputs']["default_value"] = new_value
+
                 
     print(workflow_api)
                 
@@ -193,15 +191,15 @@ async def comfy_deploy_run(request):
     prompt_server = server.PromptServer.instance
     data = await request.json()
 
-    # In older version, we use workflow_api, but this has inputs already swapped in nextjs frontend, which is tricky
-    workflow_api = data.get("workflow_api_raw")
+    workflow_api = data.get("workflow_api")
+
     # The prompt id generated from comfy deploy, can be None
     prompt_id = data.get("prompt_id")
-    inputs = data.get("inputs")
 
-    # Now it handles directly in here
     apply_random_seed_to_workflow(workflow_api)
-    apply_inputs_to_workflow(workflow_api, inputs)
+    # for key in workflow_api:
+    #     if 'inputs' in workflow_api[key] and 'seed' in workflow_api[key]['inputs']:
+    #         workflow_api[key]['inputs']['seed'] = randomSeed()
 
     prompt = {
         "prompt": workflow_api,
@@ -357,7 +355,7 @@ async def upload_file_endpoint(request):
                         with open(file_path, 'rb') as f:
                             headers = {
                                 "Content-Type": file_type,
-                                # "x-amz-acl": "public-read",
+                                "x-amz-acl": "public-read",
                                 "Content-Length": str(file_size)
                             }
                             async with session.put(upload_url, data=f, headers=headers) as upload_response:
@@ -384,58 +382,26 @@ async def upload_file_endpoint(request):
     }, status=500)
         
 
-script_dir = os.path.dirname(os.path.abspath(__file__))
-# Assuming the cache file is stored in the same directory as this script
-CACHE_FILE_PATH = script_dir + '/file-hash-cache.json'
-
-# Global in-memory cache
-file_hash_cache = {}
-
-# Load cache from disk at startup
-def load_cache():
-    global file_hash_cache
-    try:
-        with open(CACHE_FILE_PATH, 'r') as cache_file:
-            file_hash_cache = json.load(cache_file)
-    except (FileNotFoundError, json.JSONDecodeError):
-        file_hash_cache = {}
-
-# Save cache to disk
-def save_cache():
-    with open(CACHE_FILE_PATH, 'w') as cache_file:
-        json.dump(file_hash_cache, cache_file)
-
-# Initialize cache on application start
-load_cache()
-
 @server.PromptServer.instance.routes.get('/comfyui-deploy/get-file-hash')
 async def get_file_hash(request):
     file_path = request.rel_url.query.get('file_path', '')
 
-    if not file_path:
+    if file_path is None:
         return web.json_response({
             "error": "file_path is required"
         }, status=400)
     
     try:
         base = folder_paths.base_path
-        full_file_path = os.path.join(base, file_path)
-
-        # Check if the file hash is in the cache
-        if full_file_path in file_hash_cache:
-            file_hash = file_hash_cache[full_file_path]
-        else:
-            start_time = time.time()
-            file_hash = await compute_sha256_checksum(full_file_path)
-            end_time = time.time()
-            elapsed_time = end_time - start_time
-            print(f"Cache miss -> Execution time: {elapsed_time} seconds")
-
-            # Update the in-memory cache
-            file_hash_cache[full_file_path] = file_hash
-            
-            save_cache()
-
+        file_path = os.path.join(base, file_path)
+        # print("file_path", file_path)
+        start_time = time.time()  # Capture the start time
+        file_hash = await compute_sha256_checksum(
+            file_path
+        )
+        end_time = time.time()  # Capture the end time after the code execution
+        elapsed_time = end_time - start_time  # Calculate the elapsed time
+        print(f"Execution time: {elapsed_time} seconds")
         return web.json_response({
             "file_hash": file_hash
         })
@@ -687,15 +653,6 @@ async def send_json_override(self, event, data, sid=None):
         # await update_run_with_output(prompt_id, data)
 
     if event == 'executed' and 'node' in data and 'output' in data:
-        print("executed", data)
-        if prompt_id in prompt_metadata:
-            node = data.get('node')
-            class_type = prompt_metadata[prompt_id].workflow_api[node]['class_type']
-            print("executed", class_type)
-            if class_type == "PreviewImage":
-                print("skipping preview image")
-                return
-            
         await update_run_with_output(prompt_id, data.get('output'), node_id=data.get('node'))
         # await update_run_with_output(prompt_id, data.get('output'), node_id=data.get('node'))
         # update_run_with_output(prompt_id, data.get('output'))
@@ -739,7 +696,7 @@ def update_run(prompt_id: str, status: Status):
     if (prompt_metadata[prompt_id].status != status):
 
         # when the status is already failed, we don't want to update it to success
-        if (prompt_metadata[prompt_id].status is Status.FAILED):
+        if ('status' in prompt_metadata[prompt_id] and prompt_metadata[prompt_id].status == Status.FAILED):
             return
 
         status_endpoint = prompt_metadata[prompt_id].status_endpoint
@@ -828,27 +785,20 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
 
     target_url = f"{file_upload_endpoint}?file_name={filename}&run_id={prompt_id}&type={content_type}"
 
-    start_time = time.time()  # Start timing here
     result = requests.get(target_url)
-    end_time = time.time()  # End timing after the request is complete
-    print("Time taken for getting file upload endpoint: {:.2f} seconds".format(end_time - start_time))
     ok = result.json()
     
-    start_time = time.time()  # Start timing here
-    
     with open(file, 'rb') as f:
         data = f.read()
         headers = {
-            # "x-amz-acl": "public-read",
+            "x-amz-acl": "public-read",
             "Content-Type": content_type,
             "Content-Length": str(len(data)),
         }
-        # response = requests.put(ok.get("url"), headers=headers, data=data)
+        response = requests.put(ok.get("url"), headers=headers, data=data)
         async with aiohttp.ClientSession() as session:
             async with session.put(ok.get("url"), headers=headers, data=data) as response:
-                print("Upload file response", response.status)
-                end_time = time.time()  # End timing after the request is complete
-                print("Upload time: {:.2f} seconds".format(end_time - start_time))
+                print("upload file response", response.status)
 
 def have_pending_upload(prompt_id):
     if prompt_id in prompt_metadata and len(prompt_metadata[prompt_id].uploading_nodes) > 0:
@@ -934,7 +884,7 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
     # if there are no nodes that are uploading, then we set the status to success
     elif not uploading and not have_pending_upload(prompt_id) and is_prompt_done(prompt_id=prompt_id):
         update_run(prompt_id, Status.SUCCESS)
-        # print("Status: SUCCUSS")
+        print("Status: SUCCUSS")
         await send("success", {
             "prompt_id": prompt_id,
         })
@@ -942,27 +892,15 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
 async def handle_upload(prompt_id: str, data, key: str, content_type_key: str, default_content_type: str):
     items = data.get(key, [])
     for item in items:
-        # # Skipping temp files
-        if item.get("type") == "temp":
-            continue
-        
-        file_type = item.get(content_type_key, default_content_type)
-        file_extension = os.path.splitext(item.get("filename"))[1]
-        if file_extension in ['.jpg', '.jpeg']:
-            file_type = 'image/jpeg'
-        elif file_extension == '.png':
-            file_type = 'image/png'
-        elif file_extension == '.webp':
-            file_type = 'image/webp'
-        
         await upload_file(
             prompt_id,
             item.get("filename"),
             subfolder=item.get("subfolder"),
             type=item.get("type"),
-            content_type=file_type
+            content_type=item.get(content_type_key, default_content_type)
         )
 
+
 # Upload files in the background
 async def upload_in_background(prompt_id: str, data, node_id=None, have_upload=True):
     try:
@@ -970,7 +908,6 @@ async def upload_in_background(prompt_id: str, data, node_id=None, have_upload=T
         await handle_upload(prompt_id, data, 'files', "content_type", "image/png")
         # This will also be mp4
         await handle_upload(prompt_id, data, 'gifs', "format", "image/gif")
-        await handle_upload(prompt_id, data, 'mesh', "format", "application/octet-stream")
             
         if have_upload:
             await update_file_status(prompt_id, data, False, node_id=node_id)
@@ -990,23 +927,19 @@ async def update_run_with_output(prompt_id, data, node_id=None):
         "run_id": prompt_id,
         "output_data": data
     }
-    have_upload_media = 'images' in data or 'files' in data or 'gifs' in data or 'mesh' in data
-    if bypass_upload and have_upload_media:
-        print("CD_BYPASS_UPLOAD is enabled, skipping the upload of the output:", node_id)
-        return
 
-    if have_upload_media:
-        try:
-            print("\nhave_upload", have_upload_media, node_id)
+    try:
+        have_upload = 'images' in data or 'files' in data or 'gifs' in data
+        print("\nhave_upload", have_upload, node_id)
 
-            if have_upload_media:
-                await update_file_status(prompt_id, data, True, node_id=node_id)
+        if have_upload:
+            await update_file_status(prompt_id, data, True, node_id=node_id)
 
-            asyncio.create_task(upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload_media))
-            # await upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload)
+        asyncio.create_task(upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload))
 
-        except Exception as e:
-            await handle_error(prompt_id, data, e)
+    except Exception as e:
+        await handle_error(prompt_id, data, e)
+        
 
     requests.post(status_endpoint, json=body)
 
@@ -1062,9 +995,3 @@ def run_in_new_thread(coroutine):
 
 if cd_enable_log:
     run_in_new_thread(watch_file_changes(log_file_path, send_logs_to_websocket))
-
-# use after calling GET /object_info (it populates the `filename_list_cache` variable)
-@server.PromptServer.instance.routes.get("/comfyui-deploy/filename_list_cache")
-async def get_filename_list_cache(_):
-    from folder_paths import filename_list_cache
-    return web.json_response({'filename_list': filename_list_cache})

docker-compose.yaml

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

globals.py

@@ -1,21 +1,16 @@
 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
@@ -24,21 +19,8 @@ class StreamingPrompt(BaseModel):
     running_prompt_ids: set[str] = set()
     status_endpoint: str
     file_upload_endpoint: str
-    
-class SimplePrompt(BaseModel):
-    status_endpoint: str
-    file_upload_endpoint: 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:

local/Dockerfile

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

local/scripts/entrypoint.sh

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

prestartup_script.py

@@ -58,9 +58,6 @@ if cd_enable_log:
    print("** Comfy Deploy logging enabled")
    setup() 
 
-
-# Store the original working directory
-original_cwd = os.getcwd()
 try:
     # Get the absolute path of the script's directory
     script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -69,7 +66,4 @@ try:
     current_git_commit = subprocess.check_output(['git', 'rev-parse', 'HEAD']).decode('utf-8').strip()
     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)
+    print(f"** Comfy Deploy failed to get current git commit: {str(e)}")

pyproject.toml

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

requirements.txt

@@ -1,4 +1,2 @@
 aiofiles
-pydantic
-opencv-python
-imageio-ffmpeg
+pydantic

web-plugin/index.js

@@ -1,18 +1,10 @@
 import { app } from "./app.js";
 import { api } from "./api.js";
 import { ComfyWidgets, LGraphNode } from "./widgets.js";
-import { generateDependencyGraph } from "https://esm.sh/[email protected]5";
+import { generateDependencyGraph } from "https://esm.sh/[email protected]2";
 
 const loadingIcon = `<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><g fill="none" stroke="#888888" stroke-linecap="round" stroke-width="2"><path stroke-dasharray="60" stroke-dashoffset="60" stroke-opacity=".3" d="M12 3C16.9706 3 21 7.02944 21 12C21 16.9706 16.9706 21 12 21C7.02944 21 3 16.9706 3 12C3 7.02944 7.02944 3 12 3Z"><animate fill="freeze" attributeName="stroke-dashoffset" dur="1.3s" values="60;0"/></path><path stroke-dasharray="15" stroke-dashoffset="15" d="M12 3C16.9706 3 21 7.02944 21 12"><animate fill="freeze" attributeName="stroke-dashoffset" dur="0.3s" values="15;0"/><animateTransform attributeName="transform" dur="1.5s" repeatCount="indefinite" type="rotate" values="0 12 12;360 12 12"/></path></g></svg>`;
 
-function sendEventToCD(event, data) {
-  const message = {
-    type: event,
-    data: data,
-  };
-  window.parent.postMessage(JSON.stringify(message), "*");
-}
-
 /** @typedef {import('../../../web/types/comfy.js').ComfyExtension} ComfyExtension*/
 /** @type {ComfyExtension} */
 const ext = {
@@ -26,35 +18,6 @@ const ext = {
     const auth_token = queryParams.get("auth_token");
     const org_display = queryParams.get("org_display");
     const origin = queryParams.get("origin");
-    const workspace_mode = queryParams.get("workspace_mode");
-
-    if (workspace_mode) {
-      document.querySelector(".comfy-menu").style.display = "none";
-
-      sendEventToCD("cd_plugin_onInit");
-
-      app.queuePrompt = ((originalFunction) =>
-        async () => {
-          // const prompt = await app.graphToPrompt();
-          sendEventToCD("cd_plugin_onQueuePromptTrigger");
-        })(app.queuePrompt);
-
-      // // Intercept the onkeydown event
-      // window.addEventListener(
-      //   "keydown",
-      //   (event) => {
-      //     // Check for specific keys if necessary
-      //     console.log("hi");
-      //     if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
-      //       event.preventDefault();
-      //       event.stopImmediatePropagation();
-      //       event.stopPropagation();
-      //       sendEventToCD("cd_plugin_onQueuePrompt", prompt);
-      //     }
-      //   },
-      //   true,
-      // );
-    }
 
     const data = getData();
     let endpoint = data.endpoint;
@@ -189,32 +152,9 @@ const ext = {
   async setup() {
     // const graphCanvas = document.getElementById("graph-canvas");
 
-    window.addEventListener("message", async (event) => {
-      try {
-        const message = JSON.parse(event.data);
-        if (message.type === "graph_load") {
-          const comfyUIWorkflow = message.data;
-          console.log("recieved: ", comfyUIWorkflow);
-          // Assuming there's a method to load the workflow data into the ComfyUI
-          // This part of the code would depend on how the ComfyUI expects to receive and process the workflow data
-          // For demonstration, let's assume there's a loadWorkflow method in the ComfyUI API
-          if (comfyUIWorkflow && app && app.loadGraphData) {
-            app.loadGraphData(comfyUIWorkflow);
-          }
-        } else if (message.type === "deploy") {
-          // deployWorkflow();
-          const prompt = await app.graphToPrompt();
-          sendEventToCD("cd_plugin_onDeployChanges", prompt);
-        } else if (message.type === "queue_prompt") {
-          const prompt = await app.graphToPrompt();
-          sendEventToCD("cd_plugin_onQueuePrompt", prompt);
-        }
-      } catch (error) {
-        // console.error("Error processing message:", error);
-      }
-
-      // if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
-      //   return;
+    window.addEventListener("message", (event) => {
+      if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
+        return;
       //   updateBlendshapesPrompts(event.data.flow);
     });
 
@@ -227,18 +167,6 @@ const ext = {
 
       //   }
     });
-
-    app.graph.onAfterChange = ((originalFunction) =>
-      async function () {
-        const prompt = await app.graphToPrompt();
-        sendEventToCD("cd_plugin_onAfterChange", prompt);
-
-        if (typeof originalFunction === "function") {
-          originalFunction.apply(this, arguments);
-        }
-      })(app.graph.onAfterChange);
-
-    sendEventToCD("cd_plugin_setup");
   },
 };
 
@@ -339,296 +267,294 @@ function createDynamicUIHtml(data) {
   return html;
 }
 
-async function deployWorkflow() {
-  const deploy = document.getElementById("deploy-button");
-
-  /** @type {LGraph} */
-  const graph = app.graph;
-
-  let { endpoint, apiKey, displayName } = getData();
-
-  if (!endpoint || !apiKey || apiKey === "" || endpoint === "") {
-    configDialog.show();
-    return;
-  }
-
-  let deployMeta = graph.findNodesByType("ComfyDeploy");
-
-  if (deployMeta.length == 0) {
-    const text = await inputDialog.input(
-      "Create your deployment",
-      "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;
-
-  const includeDeps = document.getElementById("include-deps").checked;
-  const reuseHash = document.getElementById("reuse-hash").checked;
-
-  if (endpoint.endsWith("/")) {
-    endpoint = endpoint.slice(0, -1);
-  }
-  loadingDialog.showLoading("Generating snapshot");
-
-  const snapshot = await fetch("/snapshot/get_current").then((x) => x.json());
-  // console.log(snapshot);
-  loadingDialog.close();
-
-  if (!snapshot) {
-    showError(
-      "Error when deploying",
-      "Unable to generate snapshot, please install ComfyUI Manager",
-    );
-    return;
-  }
-
-  const title = deploy.querySelector("#button-title");
-
-  const prompt = await app.graphToPrompt();
-  let deps = undefined;
-
-  if (includeDeps) {
-    loadingDialog.showLoading("Fetching existing version");
-
-    const existing_workflow = await fetch(
-      endpoint + "/api/workflow/" + workflow_id,
-      {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + apiKey,
-        },
-      },
-    )
-      .then((x) => x.json())
-      .catch(() => {
-        return {};
-      });
-
-    loadingDialog.close();
-
-    loadingDialog.showLoading("Generating dependency graph");
-    deps = await generateDependencyGraph({
-      workflow_api: prompt.output,
-      snapshot: snapshot,
-      computeFileHash: async (file) => {
-        console.log(existing_workflow?.dependencies?.models);
-
-        // 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);
-
-          const match = previousModelHash.find((x) => {
-            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,
-    });
-
-    // Need to find a way to include this if this is not included in comfyui-json level
-    if (
-      !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 depsOk = await confirmDialog.confirm(
-      "Check dependencies",
-      // 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,
-      },
-    });
-
-    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();
+    /** @type {LGraph} */
+    const graph = app.graph;
+
+    let { endpoint, apiKey, displayName } = getData();
+
+    if (!endpoint || !apiKey || apiKey === "" || endpoint === "") {
+      configDialog.show();
+      return;
+    }
+
+    let deployMeta = graph.findNodesByType("ComfyDeploy");
+
+    if (deployMeta.length == 0) {
+      const text = await inputDialog.input(
+        "Create your deployment",
+        "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;
+
+    const includeDeps = document.getElementById("include-deps").checked;
+    const reuseHash = document.getElementById("reuse-hash").checked;
+
+    if (endpoint.endsWith("/")) {
+      endpoint = endpoint.slice(0, -1);
+    }
+    loadingDialog.showLoading("Generating snapshot");
+
+    const snapshot = await fetch("/snapshot/get_current").then((x) => x.json());
+    // console.log(snapshot);
+    loadingDialog.close();
+
+    if (!snapshot) {
+      showError(
+        "Error when deploying",
+        "Unable to generate snapshot, please install ComfyUI Manager",
+      );
+      return;
+    }
+
+    const title = deploy.querySelector("#button-title");
+
+    const prompt = await app.graphToPrompt();
+    let deps = undefined;
+
+    if (includeDeps) {
+      loadingDialog.showLoading("Fetching existing version");
+
+      const existing_workflow = await fetch(
+        endpoint + "/api/workflow/" + workflow_id,
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + apiKey,
+          },
+        },
+      )
+        .then((x) => x.json())
+        .catch(() => {
+          return {};
+        });
+
+      loadingDialog.close();
+
+      loadingDialog.showLoading("Generating dependency graph");
+      deps = await generateDependencyGraph({
+        workflow_api: prompt.output,
+        snapshot: snapshot,
+        computeFileHash: async (file) => {
+          console.log(existing_workflow?.dependencies?.models);
+
+          // 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);
+
+            const match = previousModelHash.find((x) => {
+              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,
+      });
+
+      // Need to find a way to include this if this is not included in comfyui-json level
+      if (
+        !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 depsOk = await confirmDialog.confirm(
+        "Check dependencies",
+        // 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,
+        },
+      });
+
+      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);
+    }
   };
 
   const config = document.createElement("img");

web/src/db/db.ts

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