add: name

This reverts commit 5a78ca97bd.

comfy-nodes/comfy_std_output.py

@@ -0,0 +1,46 @@
+import json
+
+
+class AnyType(str):
+    """A special class that is always equal in not equal comparisons. Credit to pythongosssss"""
+
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+any = AnyType("*")
+
+
+class ComfyDeployStdOutputAny:
+    @classmethod
+    def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+        return {
+            "required": {
+                "name": ("STRING", {"default": "ComfyUI"}),
+                "source": (any, {}),  # Use "*" to accept any input type
+            },
+        }
+
+    CATEGORY = "output"
+    RETURN_TYPES = ()
+    FUNCTION = "run"
+    OUTPUT_NODE = True
+
+    def run(self, name, source=None):
+        value = "None"
+        if source is not None:
+            try:
+                value = json.dumps(source)
+            except Exception:
+                try:
+                    value = str(source)
+                except Exception:
+                    value = "source exists, but could not be serialized."
+
+        return {"ui": {name: (value,)}}
+
+
+NODE_CLASS_MAPPINGS = {"ComfyDeployStdOutputAny": ComfyDeployStdOutputAny}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyDeployStdOutputAny": "Standard Any Output (ComfyDeploy)"
+}

comfy-nodes/comfy_std_output_image.py

@@ -0,0 +1,92 @@
+import os
+import json
+import numpy as np
+from PIL import Image
+from PIL.PngImagePlugin import PngInfo
+import folder_paths
+
+
+class ComfyDeployStdOutputImage:
+    def __init__(self):
+        self.output_dir = folder_paths.get_output_directory()
+        self.type = "output"
+        self.prefix_append = ""
+        self.compress_level = 4
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "images": ("IMAGE", {"tooltip": "The images to save."}),
+                "filename_prefix": (
+                    "STRING",
+                    {
+                        "default": "ComfyUI",
+                        "tooltip": "The prefix for the file to save. This may include formatting information such as %date:yyyy-MM-dd% or %Empty Latent Image.width% to include values from nodes.",
+                    },
+                ),
+                "file_type": (["png", "jpg", "webp"], {"default": "webp"}),
+                "quality": ("INT", {"default": 80, "min": 1, "max": 100, "step": 1}),
+            },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "run"
+
+    OUTPUT_NODE = True
+
+    CATEGORY = "output"
+    DESCRIPTION = "Saves the input images to your ComfyUI output directory."
+
+    def run(
+        self,
+        images,
+        filename_prefix="ComfyUI",
+        file_type="png",
+        quality=80,
+        prompt=None,
+        extra_pnginfo=None,
+    ):
+        filename_prefix += self.prefix_append
+        full_output_folder, filename, counter, subfolder, filename_prefix = (
+            folder_paths.get_save_image_path(
+                filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
+            )
+        )
+        results = list()
+        for batch_number, image in enumerate(images):
+            i = 255.0 * image.cpu().numpy()
+            img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+            metadata = PngInfo()
+            if prompt is not None:
+                metadata.add_text("prompt", json.dumps(prompt))
+            if extra_pnginfo is not None:
+                for x in extra_pnginfo:
+                    metadata.add_text(x, json.dumps(extra_pnginfo[x]))
+
+            filename_with_batch_num = filename.replace("%batch_num%", str(batch_number))
+            file = f"{filename_with_batch_num}_{counter:05}_.{file_type}"
+            file_path = os.path.join(full_output_folder, file)
+
+            if file_type == "png":
+                img.save(
+                    file_path, pnginfo=metadata, compress_level=self.compress_level
+                )
+            elif file_type == "jpg":
+                img.save(file_path, quality=quality, optimize=True)
+            elif file_type == "webp":
+                img.save(file_path, quality=quality)
+
+            results.append(
+                {"filename": file, "subfolder": subfolder, "type": self.type}
+            )
+            counter += 1
+
+        return {"ui": {"images": results}}
+
+
+NODE_CLASS_MAPPINGS = {"ComfyDeployStdOutputImage": ComfyDeployStdOutputImage}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyDeployStdOutputImage": "Standard Image Output (ComfyDeploy)"
+}

comfy-nodes/external_face_model.py

@@ -0,0 +1,108 @@
+from PIL import Image, ImageOps
+import numpy as np
+import torch
+import folder_paths
+
+
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+WILDCARD = AnyType("*")
+
+
+class ComfyUIDeployExternalFaceModel:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_reactor_face_model"},
+                ),
+            },
+            "optional": {
+                "default_face_model_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "face_model_save_name": (  # if `default_face_model_name` is a link to download a file, we will attempt to save it with this name
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+                "face_model_url": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+            },
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("path",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "deploy"
+
+    def run(
+        self,
+        input_id,
+        default_face_model_name=None,
+        face_model_save_name=None,
+        display_name=None,
+        description=None,
+        face_model_url=None,
+    ):
+        import requests
+        import os
+        import uuid
+
+        if face_model_url and face_model_url.startswith("http"):
+            if face_model_save_name:
+                existing_face_models = folder_paths.get_filename_list("reactor/faces")
+                # Check if face_model_save_name exists in the list
+                if face_model_save_name in existing_face_models:
+                    print(f"using face model: {face_model_save_name}")
+                    return (face_model_save_name,)
+            else:
+                face_model_save_name = str(uuid.uuid4()) + ".safetensors"
+            print(face_model_save_name)
+            print(folder_paths.folder_names_and_paths["reactor/faces"][0][0])
+            destination_path = os.path.join(
+                folder_paths.folder_names_and_paths["reactor/faces"][0][0],
+                face_model_save_name,
+            )
+
+            print(destination_path)
+            print(
+                "Downloading external face model - "
+                + face_model_url
+                + " to "
+                + destination_path
+            )
+            response = requests.get(
+                face_model_url,
+                headers={"User-Agent": "Mozilla/5.0"},
+                allow_redirects=True,
+            )
+            with open(destination_path, "wb") as out_file:
+                out_file.write(response.content)
+            return (face_model_save_name,)
+        else:
+            print(f"using face model: {default_face_model_name}")
+            return (default_face_model_name,)
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalFaceModel": ComfyUIDeployExternalFaceModel}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalFaceModel": "External Face Model (ComfyUI Deploy)"
+}

comfy-nodes/external_image_batch.py

@@ -39,14 +39,34 @@ class ComfyUIDeployExternalImageBatch:
 
     CATEGORY = "image"
     
+    def process_image(self, image):
+        image = ImageOps.exif_transpose(image)
+        image = image.convert("RGB")
+        image = np.array(image).astype(np.float32) / 255.0
+        image_tensor = torch.from_numpy(image)[None,]
+        return image_tensor
+    
     def run(self, input_id, images=None, default_value=None, display_name=None, description=None):
+        import requests
+        import zipfile
+        import io
+        
         processed_images = []
         try:
             images_list = json.loads(images)  # Assuming images is a JSON array string
             print(images_list)
             for img_input in images_list:
-                if img_input.startswith('http'):
+                if img_input.startswith('http') and img_input.endswith('.zip'):
-                    import requests
+                    print("Fetching zip file from url: ", img_input)
+                    response = requests.get(img_input)
+                    zip_file = zipfile.ZipFile(io.BytesIO(response.content))
+                    for file_name in zip_file.namelist():
+                        if file_name.lower().endswith(('.png', '.jpg', '.jpeg')):
+                            with zip_file.open(file_name) as file:
+                                image = Image.open(file)
+                                image = self.process_image(image)
+                                processed_images.append(image)
+                elif  img_input.startswith('http'):
                     from io import BytesIO
                     print("Fetching image from url: ", img_input)
                     response = requests.get(img_input)

comfy-nodes/external_text_any.py

@@ -0,0 +1,46 @@
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+WILDCARD = AnyType("*")
+
+class ComfyUIDeployExternalTextAny:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_text"},
+                ),
+            },
+            "optional": {
+                "default_value": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+            }
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "text"
+
+    def run(self, input_id, default_value=None, display_name=None, description=None):
+        return [default_value]
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalTextAny": ComfyUIDeployExternalTextAny}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalTextAny": "External Text Any (ComfyUI Deploy)"}

comfy-nodes/external_text_list.py

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

comfy-nodes/model_list.py

@@ -0,0 +1,60 @@
+import folder_paths
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+from os import walk
+
+WILDCARD = AnyType("*")
+
+MODEL_EXTENSIONS = {
+    "safetensors": "SafeTensors file format",
+    "ckpt": "Checkpoint file",
+    "pth": "PyTorch serialized file",
+    "pkl": "Pickle file",
+    "onnx": "ONNX file",
+}
+
+def fetch_files(path):
+    for (dirpath, dirnames, filenames) in walk(path):
+        fs = []
+        if len(dirnames) > 0:
+            for dirname in dirnames:
+                fs.extend(fetch_files(f"{dirpath}/{dirname}"))
+        for filename in filenames:
+            # Remove "./models/" from the beginning of dirpath
+            relative_dirpath = dirpath.replace("./models/", "", 1)
+            file_path = f"{relative_dirpath}/{filename}"
+            
+            # Only add files that are known model extensions
+            file_extension = filename.split('.')[-1].lower()
+            if file_extension in MODEL_EXTENSIONS:
+                fs.append(file_path)
+
+        return fs
+allModels = fetch_files("./models")
+
+class ComfyUIDeployModalList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (allModels, ),
+            }
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("model",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "model"
+
+    def run(self, model=""):
+        # Split the model path by '/' and select the last item
+        model_name = model.split('/')[-1]
+        return [model_name]
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployModelList": ComfyUIDeployModalList}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployModelList": "Model List (ComfyUI Deploy)"}

globals.py

@@ -6,10 +6,12 @@ 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"
@@ -17,6 +19,7 @@ class Status(Enum):
     FAILED = "failed"
     UPLOADING = "uploading"
 
+
 class StreamingPrompt(BaseModel):
     workflow_api: Any
     auth_token: str
@@ -24,42 +27,52 @@ class StreamingPrompt(BaseModel):
     running_prompt_ids: set[str] = set()
     status_endpoint: Optional[str]
     file_upload_endpoint: Optional[str]
-    
+    workflow: Any
+    gpu_event_id: Optional[str] = None
+
+
 class SimplePrompt(BaseModel):
     status_endpoint: Optional[str]
     file_upload_endpoint: Optional[str]
-    
+
+    token: Optional[str]
+
     workflow_api: dict
     status: Status = Status.NOT_STARTED
     progress: set = set()
-    last_updated_node: Optional[str] = None,
+    last_updated_node: Optional[str] = None
     uploading_nodes: set = set()
     done: bool = False
-    is_realtime: bool = False,
+    is_realtime: bool = False
-    start_time: Optional[float] = None,
+    start_time: Optional[float] = None
+    gpu_event_id: Optional[str] = None
+
 
 sockets = dict()
 prompt_metadata: dict[str, SimplePrompt] = {}
 streaming_prompt_metadata: dict[str, StreamingPrompt] = {}
 
+
 class BinaryEventTypes:
     PREVIEW_IMAGE = 1
     UNENCODED_PREVIEW_IMAGE = 2
-    
+
+
 max_output_id_length = 24
 
-async def send_image(image_data, sid=None, output_id:str = None):
+
+async def send_image(image_data, sid=None, output_id: str = None):
     max_length = max_output_id_length
     output_id = output_id[:max_length]
-    padded_output_id = output_id.ljust(max_length, '\x00')
+    padded_output_id = output_id.ljust(max_length, "\x00")
-    encoded_output_id = padded_output_id.encode('ascii', 'replace')
+    encoded_output_id = padded_output_id.encode("ascii", "replace")
-    
+
     image_type = image_data[0]
     image = image_data[1]
     max_size = image_data[2]
     quality = image_data[3]
     if max_size is not None:
-        if hasattr(Image, 'Resampling'):
+        if hasattr(Image, "Resampling"):
             resampling = Image.Resampling.BILINEAR
         else:
             resampling = Image.ANTIALIAS
@@ -83,17 +96,23 @@ async def send_image(image_data, sid=None, output_id:str = None):
     position_after = bytesIO.tell()
     bytes_written = position_after - position_before
     print(f"Bytes written: {bytes_written}")
-    
+
     image.save(bytesIO, format=image_type, quality=quality, compress_level=1)
     preview_bytes = bytesIO.getvalue()
     await send_bytes(BinaryEventTypes.PREVIEW_IMAGE, preview_bytes, sid=sid)
-        
+
+
 async def send_socket_catch_exception(function, message):
     try:
         await function(message)
-    except (aiohttp.ClientError, aiohttp.ClientPayloadError, ConnectionResetError) as err:
+    except (
+        aiohttp.ClientError,
+        aiohttp.ClientPayloadError,
+        ConnectionResetError,
+    ) as err:
         print("send error:", err)
 
+
 def encode_bytes(event, data):
     if not isinstance(event, int):
         raise RuntimeError(f"Binary event types must be integers, got {event}")
@@ -103,9 +122,10 @@ def encode_bytes(event, data):
     message.extend(data)
     return message
 
+
 async def send_bytes(event, data, sid=None):
     message = encode_bytes(event, data)
-    
+
     print("sending image to ", event, sid)
 
     if sid is None:
@@ -113,4 +133,4 @@ async def send_bytes(event, data, sid=None):
         for ws in _sockets:
             await send_socket_catch_exception(ws.send_bytes, message)
     elif sid in sockets:
-        await send_socket_catch_exception(sockets[sid].send_bytes, message)
+        await send_socket_catch_exception(sockets[sid].send_bytes, message)

pyproject.toml

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

web-plugin/index.js

@@ -83,11 +83,52 @@ function dispatchAPIEventData(data) {
   }
 }
 
+const context = {
+  selectedWorkflowInfo: null,
+};
+// let selectedWorkflowInfo = {
+//   workflow_id: "05da8f2b-63af-4c0c-86dd-08d01ec512b7",
+//   machine_id: "45ac5f85-b7b6-436f-8d97-2383b25485f3",
+//   native_run_api_endpoint: "http://localhost:3011/api/run",
+// };
+
+async function getSelectedWorkflowInfo() {
+  const workflow_info_promise = new Promise((resolve) => {
+    try {
+      const handleMessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (message.type === "workflow_info") {
+            resolve(message.data);
+            window.removeEventListener("message", handleMessage);
+          }
+        } catch (error) {
+          console.error(error);
+          resolve(undefined);
+        }
+      };
+      window.addEventListener("message", handleMessage);
+      sendEventToCD("workflow_info");
+    } catch (error) {
+      console.error(error);
+      resolve(undefined);
+    }
+  });
+
+  return workflow_info_promise;
+}
+
+function setSelectedWorkflowInfo(info) {
+  context.selectedWorkflowInfo = info;
+}
+
 /** @typedef {import('../../../web/types/comfy.js').ComfyExtension} ComfyExtension*/
 /** @type {ComfyExtension} */
 const ext = {
   name: "BennyKok.ComfyUIDeploy",
 
+  native_mode: false,
+
   init(app) {
     addButton();
 
@@ -97,16 +138,17 @@ const ext = {
     const org_display = queryParams.get("org_display");
     const origin = queryParams.get("origin");
     const workspace_mode = queryParams.get("workspace_mode");
+    this.native_mode = queryParams.get("native_mode") === "true";
 
     if (workspace_mode) {
       document.querySelector(".comfy-menu").style.display = "none";
 
       sendEventToCD("cd_plugin_onInit");
 
-      app.queuePrompt = ((originalFunction) => async () => {
+      // app.queuePrompt = ((originalFunction) => async () => {
-        // const prompt = await app.graphToPrompt();
+      //   // const prompt = await app.graphToPrompt();
-        sendEventToCD("cd_plugin_onQueuePromptTrigger");
+      //   sendEventToCD("cd_plugin_onQueuePromptTrigger");
-      })(app.queuePrompt);
+      // })(app.queuePrompt);
 
       // // Intercept the onkeydown event
       // window.addEventListener(
@@ -213,7 +255,7 @@ const ext = {
           (v) => {
             this.properties.workflow_name = v;
           },
-          { multiline: false }
+          { multiline: false },
         );
 
         this.addWidget(
@@ -223,7 +265,7 @@ const ext = {
           (v) => {
             this.properties.workflow_id = v;
           },
-          { multiline: false }
+          { multiline: false },
         );
 
         this.addWidget(
@@ -233,7 +275,7 @@ const ext = {
           (v) => {
             this.properties.version = v;
           },
-          { multiline: false }
+          { multiline: false },
         );
 
         this.widgets_start_y = 10;
@@ -270,11 +312,14 @@ const ext = {
     }
 
     // Register the node type
-    LiteGraph.registerNodeType("ComfyDeploy", Object.assign(ComfyDeploy, {
+    LiteGraph.registerNodeType(
-      title: "Comfy Deploy",
+      "ComfyDeploy",
-      title_mode: LiteGraph.NORMAL_TITLE,
+      Object.assign(ComfyDeploy, {
-      collapsable: true,
+        title: "Comfy Deploy",
-    }));
+        title_mode: LiteGraph.NORMAL_TITLE,
+        collapsable: true,
+      }),
+    );
 
     ComfyDeploy.category = "deploy";
   },
@@ -293,6 +338,17 @@ const ext = {
           // 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) {
+            try {
+              await window["app"].ui.settings.setSettingValueAsync(
+                "Comfy.Validation.Workflows",
+                false,
+              );
+            } catch (error) {
+              console.warning(
+                "Error setting validation to false, is fine to ignore this",
+                error,
+              );
+            }
             console.log("loadGraphData");
             app.loadGraphData(comfyUIWorkflow);
           }
@@ -380,6 +436,8 @@ const ext = {
           }
 
           animate();
+        } else if (message.type === "workflow_info") {
+          setSelectedWorkflowInfo(message.data);
         }
         // else if (message.type === "refresh") {
         //   sendEventToCD("cd_plugin_onRefresh");
@@ -399,6 +457,25 @@ const ext = {
       //   }
     });
 
+    if (this.native_mode) {
+      // console.log("native mode", window, window.app);
+      try {
+        await app.ui.settings.setSettingValueAsync("Comfy.UseNewMenu", "Top");
+        await app.ui.settings.setSettingValueAsync(
+          "Comfy.Sidebar.Size",
+          "small"
+        );
+        await app.ui.settings.setSettingValueAsync(
+          "Comfy.Sidebar.Location",
+          "right"
+        );
+        localStorage.setItem("Comfy.MenuPosition.Docked", "true");
+        console.log("native mode manmanman");
+      } catch (error) {
+        console.error("Error setting validation to false", error);
+      }
+    }
+
     app.graph.onAfterChange = ((originalFunction) =>
       async function () {
         const prompt = await app.graphToPrompt();
@@ -443,10 +520,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>
   `;
   }
@@ -454,14 +531,17 @@ function createDynamicUIHtml(data) {
   Object.values(data.custom_nodes).forEach((node) => {
     html += `
           <div style="border-bottom: 1px solid #e2e8f0; padding-top: 16px;">
-              <a href="${node.url
+              <a href="${
-      }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${node.name
+                node.url
-      }</a>
+              }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${
+                node.name
+              }</a>
               <p style="font-size: 14px; color: #4b5563;">${node.hash}</p>
-              ${node.warning
+              ${
-        ? `<p style="font-size: 14px; color: #d69e2e;">${node.warning}</p>`
+                node.warning
-        : ""
+                  ? `<p style="font-size: 14px; color: #d69e2e;">${node.warning}</p>`
-      }
+                  : ""
+              }
           </div>
       `;
   });
@@ -475,8 +555,9 @@ function createDynamicUIHtml(data) {
   Object.entries(data.models).forEach(([section, items]) => {
     html += `
     <div style="border-bottom: 1px solid #e2e8f0; padding-top: 8px; padding-bottom: 8px;">
-        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${
-      }</h3>`;
+          section.charAt(0).toUpperCase() + section.slice(1)
+        }</h3>`;
     items.forEach((item) => {
       html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
     });
@@ -492,8 +573,9 @@ function createDynamicUIHtml(data) {
   Object.entries(data.files).forEach(([section, items]) => {
     html += `
     <div style="border-bottom: 1px solid #e2e8f0; padding-top: 8px; padding-bottom: 8px;">
-        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${
-      }</h3>`;
+          section.charAt(0).toUpperCase() + section.slice(1)
+        }</h3>`;
     items.forEach((item) => {
       html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
     });
@@ -1013,12 +1095,14 @@ export class LoadingDialog extends ComfyDialog {
   showLoading(title, message) {
     this.show(`
       <div style="width: 400px; display: flex; gap: 18px; flex-direction: column; overflow: unset">
-        <h3 style="margin: 0px; display: flex; align-items: center; justify-content: center; gap: 12px;">${title} ${this.loadingIcon
+        <h3 style="margin: 0px; display: flex; align-items: center; justify-content: center; gap: 12px;">${title} ${
-      }</h3>
+          this.loadingIcon
-          ${message
+        }</h3>
-        ? `<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>
       `);
   }
@@ -1284,17 +1368,21 @@ export class ConfigDialog extends ComfyDialog {
     </label>
       <label style="color: white; width: 100%;">
         Endpoint:
-        <input id="endpoint" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="text" value="${data.endpoint
+        <input id="endpoint" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="text" value="${
-      }">
+          data.endpoint
+        }">
       </label>
       <div style="color: white;">
-        API Key: User / Org <button style="font-size: 18px;">${data.displayName ?? ""
+        API Key: User / Org <button style="font-size: 18px;">${
-      }</button>
+          data.displayName ?? ""
-        <input id="apiKey" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="password" value="${data.apiKey
+        }</button>
-      }">
+        <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>
@@ -1483,3 +1571,38 @@ async function loadWorkflowApi(versionId) {
     // Show an error message to the user
   }
 }
+
+const orginal_fetch_api = api.fetchApi;
+api.fetchApi = async (route, options) => {
+  console.log("Fetch API called with args:", route, options, ext.native_mode);
+
+  if (route.startsWith("/prompt") && ext.native_mode) {
+    const info = await getSelectedWorkflowInfo();
+    console.log("info", info);
+    if (info) {
+      const body = JSON.parse(options.body);
+
+      const data = {
+        client_id: body.client_id,
+        workflow_api_json: body.prompt,
+        workflow: body?.extra_data?.extra_pnginfo?.workflow,
+        is_native_run: true,
+        machine_id: info.machine_id,
+        workflow_id: info.workflow_id,
+        native_run_api_endpoint: info.native_run_api_endpoint,
+        gpu_event_id: info.gpu_event_id,
+      };
+
+      return await fetch("/comfyui-deploy/run", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${info.cd_token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(data),
+      });
+    }
+  }
+
+  return await orginal_fetch_api.call(api, route, options);
+};

web/src/components/customInputNodes.tsx

@@ -6,4 +6,5 @@ export const customInputNodes: Record<string, string> = {
   ComfyUIDeployExternalNumberInt: "integer",
   ComfyUIDeployExternalLora: "string - (public lora download url)",
   ComfyUIDeployExternalCheckpoint: "string - (public checkpoints download url)",
+  ComfyUIDeployExternalFaceModel: "string - (public face model download url)",
 };