Bump CD ver to 2.3.1 in Manager

* initt: add machine management functionality

- Implemented a new endpoint in custom_routes.py to retrieve machine details by ID.
- Introduced machine-manager.js to handle machine data fetching, display, and local storage management.
- Updated index.js to initialize the machine manager and display machine information in the UI.
- Adjusted workflow-list.js to modify the layout for better integration with the new machine management features.

These changes enhance the application's capability to manage and display serverless machine information effectively.

* refactor: enhance machine management UI and functionality

- Removed console error logs for improved user experience during initialization.
- Updated the display styles for "No machine found" and error messages to enhance visual clarity.
- Added buttons for adding and updating machines directly from the error and no machine states.
- Implemented a dialog for adding and updating machine IDs, improving user interaction.
- Adjusted the machine addition process to show loading states and ensure proper DOM updates.

These changes significantly improve the usability and functionality of the machine management feature.

* add: machine id when create

* remove unused code

* fetch docker steps in backend

* compare list

* can sync machine

* add: create machine from local

* add error

* add: blacklist node

* refactor: improve snapshot fetching and UI adjustments

- Introduced centralized snapshot fetching utilities in snapshot-utils.js, including a fallback for ComfyUI version retrieval.
- Updated machine-manager.js to utilize the new snapshot fetching methods, enhancing error handling and code clarity.
- Adjusted index.js to streamline snapshot fetching during workflow deployment.
- Made minor UI adjustments in workflow-list.js for better layout consistency.

These changes enhance the application's robustness in handling snapshots and improve overall user experience.

* small tweak

* tweak machine display

* chore: version to 2.3.0

custom_routes.py

@@ -265,7 +265,7 @@ def clear_current_prompt(sid):
     streaming_prompt_metadata[sid].running_prompt_ids.clear()
 
 
-def post_prompt(json_data):
+async def post_prompt(json_data):
     prompt_server = server.PromptServer.instance
     json_data = prompt_server.trigger_on_prompt(json_data)
 
@@ -281,7 +281,48 @@ def post_prompt(json_data):
 
     if "prompt" in json_data:
         prompt = json_data["prompt"]
-        valid = execution.validate_prompt(prompt)
+        prompt_id = json_data.get("prompt_id") or str(uuid.uuid4())
+
+        partial_execution_targets = None
+        if "partial_execution_targets" in json_data:
+            partial_execution_targets = json_data["partial_execution_targets"]
+
+        # Handle different validate_prompt signatures (newest to oldest)
+        valid = None
+        last_error = None
+
+        # v0.3.48 (3 args)
+        try:
+            valid = await execution.validate_prompt(
+                prompt_id, prompt, partial_execution_targets
+            )
+        except TypeError as e:
+            last_error = e
+            logger.debug(
+                f"validate_prompt with 3 params not supported, trying with 2. Debug: {last_error}"
+            )
+
+        # v0.3.45 - 0.3.47 (2 args)
+        if valid is None:
+            try:
+                valid = await execution.validate_prompt(prompt_id, prompt)
+            except TypeError as e:
+                last_error = e
+                logger.debug(
+                    f"validate_prompt with 2 params not supported, trying legacy signature. Debug: {last_error}"
+                )
+
+        # v0.3.44 or older (1 arg)
+        if valid is None:
+            try:
+                valid = execution.validate_prompt(prompt)
+            except TypeError as e:
+                last_error = e
+                logger.error(
+                    f"validate_prompt failed with all signatures. Last error: {last_error}"
+                )
+                raise
+
         extra_data = {}
         if "extra_data" in json_data:
             extra_data = json_data["extra_data"]
@@ -292,8 +333,6 @@ def post_prompt(json_data):
         if "client_id" in json_data:
             extra_data["client_id"] = json_data["client_id"]
         if valid[0]:
-            # if the prompt id is provided
-            prompt_id = json_data.get("prompt_id") or str(uuid.uuid4())
             outputs_to_execute = valid[2]
             prompt_server.prompt_queue.put(
                 (number, prompt_id, prompt, extra_data, outputs_to_execute)
@@ -500,15 +539,15 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
 
     prompt_id = str(uuid.uuid4())
 
-    prompt = {
-        "prompt": workflow_api,
-        "client_id": sid,  # "comfy_deploy_instance", #api.client_id
-        "prompt_id": prompt_id,
-        "extra_data": {"extra_pnginfo": {"workflow": workflow}},
-    }
+    # prompt = {
+    #     "prompt": workflow_api,
+    #     "client_id": sid,  # "comfy_deploy_instance", #api.client_id
+    #     "prompt_id": prompt_id,
+    #     "extra_data": {"extra_pnginfo": {"workflow": workflow}},
+    # }
 
     try:
-        res = post_prompt(prompt)
+        # res = post_prompt(prompt)
         inputs.running_prompt_ids.add(prompt_id)
         prompt_metadata[prompt_id] = SimplePrompt(
             status_endpoint=inputs.status_endpoint,
@@ -519,7 +558,7 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
     except Exception as e:
         error_type = type(e).__name__
         stack_trace_short = traceback.format_exc().strip().split("\n")[-2]
-        stack_trace = traceback.format_exc().strip()
+        # stack_trace = traceback.format_exc().strip()
         logger.info(f"error: {error_type}, {e}")
         logger.info(f"stack trace: {stack_trace_short}")
 
@@ -595,7 +634,7 @@ async def comfy_deploy_run(request):
     )
 
     try:
-        res = post_prompt(prompt)
+        res = await post_prompt(prompt)
     except Exception as e:
         error_type = type(e).__name__
         stack_trace_short = traceback.format_exc().strip().split("\n")[-2]
@@ -664,7 +703,7 @@ async def stream_prompt(data, token):
     # log('info', "Begin prompt", prompt=prompt)
 
     try:
-        res = post_prompt(prompt)
+        res = await post_prompt(prompt)
     except Exception as e:
         error_type = type(e).__name__
         stack_trace_short = traceback.format_exc().strip().split("\n")[-2]
@@ -1266,22 +1305,11 @@ def handle_execute(class_type, last_node_id, prompt_id, server, unique_id):
 
 try:
     origin_execute = execution.execute
+    is_async = asyncio.iscoroutinefunction(origin_execute)
 
-    def swizzle_execute(
-        server,
-        dynprompt,
-        caches,
-        current_item,
-        extra_data,
-        executed,
-        prompt_id,
-        execution_list,
-        pending_subgraph_results,
-    ):
-        unique_id = current_item
-        class_type = dynprompt.get_node(unique_id)["class_type"]
-        last_node_id = server.last_node_id
-        result = origin_execute(
+    if is_async:
+
+        async def swizzle_execute(
             server,
             dynprompt,
             caches,
@@ -1291,12 +1319,61 @@ try:
             prompt_id,
             execution_list,
             pending_subgraph_results,
-        )
-        handle_execute(class_type, last_node_id, prompt_id, server, unique_id)
-        return result
+            pending_async_nodes,
+        ):
+            unique_id = current_item
+            class_type = dynprompt.get_node(unique_id)["class_type"]
+            last_node_id = server.last_node_id
+
+            result = await origin_execute(
+                server,
+                dynprompt,
+                caches,
+                current_item,
+                extra_data,
+                executed,
+                prompt_id,
+                execution_list,
+                pending_subgraph_results,
+                pending_async_nodes,
+            )
+
+            handle_execute(class_type, last_node_id, prompt_id, server, unique_id)
+            return result
+    else:
+
+        def swizzle_execute(
+            server,
+            dynprompt,
+            caches,
+            current_item,
+            extra_data,
+            executed,
+            prompt_id,
+            execution_list,
+            pending_subgraph_results,
+        ):
+            unique_id = current_item
+            class_type = dynprompt.get_node(unique_id)["class_type"]
+            last_node_id = server.last_node_id
+
+            result = origin_execute(
+                server,
+                dynprompt,
+                caches,
+                current_item,
+                extra_data,
+                executed,
+                prompt_id,
+                execution_list,
+                pending_subgraph_results,
+            )
+
+            handle_execute(class_type, last_node_id, prompt_id, server, unique_id)
+            return result
 
     execution.execute = swizzle_execute
-except Exception as e:
+except Exception:
     pass
 
 
@@ -1440,10 +1517,6 @@ async def send_json_override(self, event, data, sid=None):
             logger.info(format_table(headers, table_data))
             # print("========================\n")
 
-            timeline = format_execution_timeline(NODE_EXECUTION_TIMES)
-            logger.info(f"\nNode Execution Timeline:\n{timeline}")
-            # Clear the execution times for the next run
-
     # the last executing event is none, then the workflow is finished
     if event == "executing" and data.get("node") is None:
         mark_prompt_done(prompt_id=prompt_id)
@@ -2059,6 +2132,7 @@ async def upload_in_background(
                 ("model_file", "format", "application/octet-stream"),
                 ("result", "format", "application/octet-stream"),
                 ("text_file", "format", "text/plain"),
+                ("audio", "format", "audio/mpeg"),
             ]:
                 items = data.get(file_type, [])
 
@@ -2146,6 +2220,7 @@ async def update_run_with_output(
             or "model_file" in data
             or "result" in data
             or "text_file" in data
+            or "audio" in data
         )
     if bypass_upload and have_upload_media:
         print(
@@ -2754,59 +2829,57 @@ class UploadQueue:
                     logger.error(f"Upload failed: {str(e)}")
                     logger.error(traceback.format_exc())
                 finally:
-                    # Remove this upload from tracking
-                    if prompt_id in self.pending_uploads:
-                        self.pending_uploads[prompt_id].discard(upload_id)
-                        # Remove from node tracking if applicable
-                        if (
-                            node_id
-                            and prompt_id in self.node_uploads
-                            and node_id in self.node_uploads[prompt_id]
-                        ):
-                            self.node_uploads[prompt_id][node_id].discard(upload_id)
+                    async with self.lock:  # Acquire lock to protect shared dict access
+                        if prompt_id in self.pending_uploads:
+                            self.pending_uploads[prompt_id].discard(upload_id)
 
-                            # If this was the last upload for this node, clean up node data
-                            if not self.node_uploads[prompt_id][node_id]:
-                                del self.node_uploads[prompt_id][node_id]
-                                if prompt_id in self.node_output_data:
-                                    if node_id in self.node_output_data[prompt_id]:
-                                        if self.node_output_data[prompt_id][node_id][
-                                            "data"
-                                        ]:
-                                            # Send final node data to API before cleanup
-                                            if prompt_metadata[
-                                                prompt_id
-                                            ].status_endpoint:
-                                                body = {
-                                                    "run_id": prompt_id,
-                                                    "output_data": self.node_output_data[
+                            if (
+                                node_id
+                                and prompt_id in self.node_uploads
+                                and node_id in self.node_uploads[prompt_id]
+                            ):
+                                self.node_uploads[prompt_id][node_id].discard(upload_id)
+
+                                if not self.node_uploads[prompt_id][node_id]:
+                                    del self.node_uploads[prompt_id][node_id]
+
+                                    if (
+                                        prompt_id in self.node_output_data
+                                        and node_id in self.node_output_data[prompt_id]
+                                    ):
+                                        node_data = self.node_output_data[prompt_id][
+                                            node_id
+                                        ]
+                                        if node_data["data"]:
+                                            body = {
+                                                "run_id": prompt_id,
+                                                "output_data": node_data["data"],
+                                                "node_meta": {"node_id": node_id},
+                                            }
+                                            try:
+                                                await async_request_with_retry(
+                                                    "POST",
+                                                    prompt_metadata[
                                                         prompt_id
-                                                    ][node_id]["data"],
-                                                    "node_meta": {"node_id": node_id},
-                                                }
-                                                try:
-                                                    await async_request_with_retry(
-                                                        "POST",
-                                                        prompt_metadata[
-                                                            prompt_id
-                                                        ].status_endpoint,
-                                                        token=prompt_metadata[
-                                                            prompt_id
-                                                        ].token,
-                                                        json=body,
-                                                    )
-                                                except Exception as e:
-                                                    logger.error(
-                                                        f"Failed to send final node data: {str(e)}"
-                                                    )
+                                                    ].status_endpoint,
+                                                    token=prompt_metadata[
+                                                        prompt_id
+                                                    ].token,
+                                                    json=body,
+                                                )
+                                            except Exception as e:
+                                                logger.error(
+                                                    f"Failed to send final node data: {str(e)}"
+                                                )
+
+                                        # Safe to delete now (re-check not strictly needed with lock, but harmless)
                                         del self.node_output_data[prompt_id][node_id]
 
-                        # Send status update
-                        await self.update_queue_status(prompt_id)
-
                         # If no more pending uploads for this prompt and it's done, update status
-                        if not self.pending_uploads[prompt_id] and is_prompt_done(
-                            prompt_id
+                        if (
+                            prompt_id in self.pending_uploads
+                            and not self.pending_uploads[prompt_id]
+                            and is_prompt_done(prompt_id)
                         ):
                             # Clean up all data for this prompt
                             if prompt_id in self.node_uploads:
@@ -2819,9 +2892,12 @@ class UploadQueue:
                             loop.create_task(update_run(prompt_id, Status.SUCCESS))
                             loop.create_task(send("success", {"prompt_id": prompt_id}))
 
-                    # Mark task as done
+                    # Mark task as done (outside lock to avoid holding it unnecessarily)
                     self.queue.task_done()
 
+                    # Send status update (also outside lock)
+                    await self.update_queue_status(prompt_id)
+
             except Exception as e:
                 logger.error(f"Error in upload worker: {str(e)}")
                 logger.error(traceback.format_exc())
@@ -2919,6 +2995,7 @@ async def create_workflow_proxy(request):
     name = data.get("name")
     workflow_json = data.get("workflow_json")
     workflow_api = data.get("workflow_api")
+    machine_id = data.get("machine_id")
     api_url = data.get("api_url", "https://api.comfydeploy.com")
 
     auth_header = request.headers.get("Authorization")
@@ -2938,6 +3015,7 @@ async def create_workflow_proxy(request):
         "name": name,
         "workflow_json": json.dumps(workflow_json),
         "workflow_api": json.dumps(workflow_api),
+        "machine_id": machine_id,
     }
 
     try:
@@ -3060,3 +3138,147 @@ async def get_workflow_proxy(request):
             return web.json_response(json_data, status=response.status)
     except Exception as e:
         return web.json_response({"error": str(e)}, status=500)
+
+
+# for getting a machine by id
+@server.PromptServer.instance.routes.get("/comfyui-deploy/machine")
+async def get_machine_proxy(request):
+    machine_id = request.rel_url.query.get("machine_id")
+    api_url = request.rel_url.query.get("api_url", "https://api.comfydeploy.com")
+    auth_header = request.headers.get("Authorization")
+
+    if not auth_header:
+        return web.json_response(
+            {"error": "Authorization header is required"}, status=401
+        )
+
+    target_url = f"{api_url}/api/machine/{machine_id}"
+
+    try:
+        await ensure_client_session()
+        async with client_session.get(
+            target_url, headers={"Authorization": auth_header}
+        ) as response:
+            json_data = await response.json()
+            return web.json_response(json_data, status=response.status)
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+# for fetching docker steps from current snapshot
+@server.PromptServer.instance.routes.post("/comfyui-deploy/snapshot-to-docker")
+async def snapshot_to_docker_proxy(request):
+    data = await request.json()
+    snapshot = data.get("snapshot")
+    api_url = data.get("api_url", "https://api.comfydeploy.com")
+    auth_header = request.headers.get("Authorization")
+
+    if not auth_header:
+        return web.json_response(
+            {"error": "Authorization header is required"}, status=401
+        )
+
+    target_url = f"{api_url}/api/snapshot-to-docker"
+
+    request_body = snapshot
+
+    try:
+        await ensure_client_session()
+        async with client_session.post(
+            target_url, json=request_body, headers={"Authorization": auth_header}
+        ) as response:
+            json_data = await response.json()
+            return web.json_response(json_data, status=response.status)
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+# update a serverless machine with machine id
+@server.PromptServer.instance.routes.post("/comfyui-deploy/machine/update")
+async def update_machine_proxy(request):
+    data = await request.json()
+    machine_id = data.get("machine_id")
+    comfyui_version = data.get("comfyui_version", None)
+    docker_steps = data.get("docker_steps")
+    api_url = data.get("api_url", "https://api.comfydeploy.com")
+    auth_header = request.headers.get("Authorization")
+
+    if not auth_header:
+        return web.json_response(
+            {"error": "Authorization header is required"}, status=401
+        )
+
+    target_url = f"{api_url}/api/machine/serverless/{machine_id}"
+
+    request_body = {"docker_command_steps": docker_steps}
+
+    if comfyui_version:
+        request_body["comfyui_version"] = comfyui_version
+
+    try:
+        await ensure_client_session()
+        async with client_session.patch(
+            target_url, json=request_body, headers={"Authorization": auth_header}
+        ) as response:
+            json_data = await response.json()
+            return web.json_response(json_data, status=response.status)
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+@server.PromptServer.instance.routes.post("/comfyui-deploy/machine/create")
+async def create_machine_proxy(request):
+    data = await request.json()
+    name = data.get("name")
+    docker_command_steps = data.get("docker_command_steps")
+    comfyui_version = data.get("comfyui_version")
+    api_url = data.get("api_url", "https://api.comfydeploy.com")
+    auth_header = request.headers.get("Authorization")
+
+    if not auth_header:
+        return web.json_response(
+            {"error": "Authorization header is required"}, status=401
+        )
+
+    target_url = f"{api_url}/api/machine/serverless"
+
+    request_body = {
+        "name": name,
+        "docker_command_steps": docker_command_steps,
+        "comfyui_version": comfyui_version,
+        "gpu": "A10G",
+    }
+
+    try:
+        await ensure_client_session()
+        async with client_session.post(
+            target_url, json=request_body, headers={"Authorization": auth_header}
+        ) as response:
+            json_data = await response.json()
+            return web.json_response(json_data, status=response.status)
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)
+
+
+# get latest comfyui version
+@server.PromptServer.instance.routes.get("/comfyui-deploy/comfyui-version")
+async def get_comfyui_version_proxy(request):
+    api_url = request.rel_url.query.get("api_url", "https://api.comfydeploy.com")
+    auth_header = request.headers.get("Authorization")
+
+    if not auth_header:
+        return web.json_response(
+            {"error": "Authorization header is required"}, status=401
+        )
+
+    target_url = f"{api_url}/api/latest-hashes"
+
+    try:
+        await ensure_client_session()
+        async with client_session.get(
+            target_url, headers={"Authorization": auth_header}
+        ) as response:
+            json_data = await response.json()
+            return web.json_response(json_data, status=response.status)
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)

pyproject.toml

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

web-plugin/index.js

@@ -4,6 +4,8 @@ import { api } from "../../scripts/api.js";
 LGraphNode = LiteGraph.LGraphNode;
 import { ComfyDialog, $el } from "../../scripts/ui.js";
 import { initializeWorkflowsList, addWorkflowSearch } from "./workflow-list.js";
+import { initializeMachineManager } from "./machine-manager.js";
+import { fetchSnapshotSimple } from "./snapshot-utils.js";
 
 import { generateDependencyGraph } from "https://esm.sh/comfyui-json@0.1.25";
 // import { ComfyDeploy } from "https://esm.sh/comfydeploy@2.0.0-beta.69";
@@ -999,7 +1001,10 @@ const ext = {
           "Comfy.Sidebar.Location",
           "left"
         );
-        // localStorage.setItem("Comfy.MenuPosition.Docked", "true");
+        await app.ui.settings.setSettingValueAsync(
+          "Comfy.TutorialCompleted",
+          true
+        );
         console.log("native mode manmanman");
       } catch (error) {
         console.error("Error setting validation to false", error);
@@ -1168,24 +1173,12 @@ async function deployWorkflow() {
     <br>
     <button style="font-size: 18px;">${endpoint}</button>
 
-    <br><br>
-    <label>
-    <input id="include-deps" type="checkbox">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;
-
   const prompt = await app.graphToPrompt();
-  let deps = undefined;
 
   console.log(prompt);
 
@@ -1241,7 +1234,7 @@ async function deployWorkflow() {
   }
   loadingDialog.showLoading("Generating snapshot");
 
-  const snapshot = await fetch("/snapshot/get_current").then((x) => x.json());
+  const snapshot = await fetchSnapshotSimple();
   console.log(snapshot);
   loadingDialog.close();
 
@@ -1255,136 +1248,6 @@ async function deployWorkflow() {
 
   const title = deploy.querySelector("#button-title");
 
-  if (includeDeps) {
-    loadingDialog.showLoading("Fetching existing version");
-
-    const existing_workflow = await fetch(
-      apiUrl + "/api/workflow/" + workflow_id,
-      {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + apiKey,
-        },
-      }
-    )
-      .then((x) => x.json())
-      .catch(() => {
-        return {};
-      });
-
-    console.log("workflow", existing_workflow);
-
-    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();
-    console.log(deps);
-
-    const depsOk = await confirmDialog.confirm(
-      "Check dependencies",
-      // JSON.stringify(deps, null, 2),
-      `
-      <div>
-        You will need to create a cloud machine with the following configuration on ComfyDeploy
-        <ol style="text-align: left; margin-top: 10px;">
-            <li>Review the dependencies listed in the graph below</li>
-            <li>Create a new cloud machine with the required configuration</li>
-            <li>Install missing models and check missing files</li>
-            <li>Deploy your workflow to the newly created machine</li>
-        </ol>
-      </div>
-      <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;
-  }
-
   loadingDialog.showLoading("Deploying...");
 
   title.innerText = "Deploying...";
@@ -1397,6 +1260,10 @@ async function deployWorkflow() {
       workflow_api: prompt.output,
       api_url: apiUrl,
     };
+    const machineId = localStorage.getItem("comfy_deploy_machine_id");
+    if (machineId) {
+      body.machine_id = machineId;
+    }
     console.log(body);
     let data = await fetch("/comfyui-deploy/workflow", {
       method: "POST",
@@ -2000,13 +1867,10 @@ const currentOrigin = window.location.origin;
 //   serverURL: `${currentOrigin}/comfydeploy/api/`,
 // });
 
-// Check if the current URL hostname starts with localhost or 127.0.0.1
-const isLocalhost =
-  window.location.hostname === "localhost" ||
-  window.location.hostname === "127.0.0.1";
+const isComfyDeployDashboard = currentOrigin.includes("comfydeploy.com");
 
 // Only register the sidebar tab if we're on localhost
-if (isLocalhost) {
+if (!isComfyDeployDashboard) {
   app.extensionManager.registerSidebarTab({
     id: "search",
     icon: "pi pi-cloud-upload",
@@ -2018,6 +1882,13 @@ if (isLocalhost) {
         <div style="padding: 20px;">
           <h3>Comfy Deploy</h3>
           <div id="deploy-container" style="margin-bottom: 20px;"></div>
+          <div id="machine-container" style="margin-bottom: 20px;">
+            <h4>Serverless Machine</h4>
+            <div id="machine-loading" style="display: flex; justify-content: center; align-items: center; height: 100px;">
+              ${loadingIcon}
+            </div>
+            <ul id="machine-list" style="list-style-type: none; padding: 0; display: none;"></ul>
+          </div>
           <div id="workflows-container" style="display: none;">
             <h4>Your Workflows</h4>
             <div id="workflows-loading" style="display: flex; justify-content: center; align-items: center; height: 100px;">
@@ -2078,6 +1949,9 @@ if (isLocalhost) {
       const workflowsList = el.querySelector("#workflows-list");
       const workflowsLoading = el.querySelector("#workflows-loading");
 
+      // Initialize machine manager
+      await initializeMachineManager(el, getData);
+
       // Initialize workflows list and search
       const data = getData();
       if (data.apiKey) {

web-plugin/snapshot-utils.js

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

web-plugin/workflow-list.js

@@ -279,7 +279,7 @@ async function initializeWorkflowsList(element, getData, getTimeAgo) {
         list-style-type: none;
         padding: 0;
         margin: 0;
-        height: calc(100vh - 350px);
+        height: calc(100vh - 550px);
         overflow-y: auto;
         scrollbar-width: thin;
         scrollbar-color: #666 transparent;