fix: no venv

Signed-off-by: Frost Ming <me@frostming.com>

.gitignore

@@ -161,3 +161,5 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 /temp/
+src/.DS_Store
+.DS_Store

nodes/__init__.py

@@ -1,8 +1,7 @@
-import sys
 import pathlib
-
+import sys
 
 SRC_DIR = pathlib.Path(__file__).parent.parent / "src"
 
 if str(SRC_DIR) not in sys.path:
-    sys.path.append(str(SRC_DIR))
+    sys.path.insert(0, str(SRC_DIR))

nodes/api.py

@@ -11,7 +11,7 @@ import tempfile
 import time
 import uuid
 import zipfile
-from importlib.metadata import Distribution, distributions
+from fnmatch import fnmatch
 from pathlib import Path
 from typing import Any, Union
 
@@ -26,53 +26,63 @@ from comfy_pack.package import build_bento
 ZPath = Union[Path, zipfile.Path]
 TEMP_FOLDER = Path(__file__).parent.parent / "temp"
 COMFY_PACK_DIR = Path(__file__).parent.parent / "src" / "comfy_pack"
-EXCLUDE_PACKAGES = ["bentoml", "onnxruntime", "conda"]  # TODO: standardize this
+EXCLUDE_PACKAGES = ["bentoml", "onnxruntime", "conda", "nvidia-*"]
 
 
-def _get_requirement_string(dist: Distribution) -> str:
-    direct_url_text = dist.read_text("direct_url.json")
-    pinned_str = f'{dist.metadata["Name"]}=={dist.version}'
-    if not direct_url_text:
-        return pinned_str
-    direct_url = json.loads(direct_url_text)
-    if url := direct_url.get("url"):
-        if url.startswith("file://"):
-            # we are not able to share local files
-            return pinned_str
-        if vcs_info := direct_url.get("vcs_info"):
-            url = f"{vcs_info['vcs']}+{url}@{vcs_info['commit_id']}"
-        if subdirectory := direct_url.get("subdirectory"):
-            url += f"#subdirectory={subdirectory}"
-        return f"{dist.metadata['Name']} @ {url}"
-    else:
-        return pinned_str
+def normalize_name(name: str) -> str:
+    import re
+
+    return re.sub(r"[-_.]+", "-", name).lower()
 
 
-async def _write_requirements(path: ZPath, extras: list[str] | None = None) -> None:
-    print("Package => Writing requirements.txt")
-    with path.joinpath("requirements.txt").open("w") as f:
-        for dist in distributions():
-            f.write(_get_requirement_string(dist) + "\n")
-        if extras:
-            f.write("\n".join(extras) + "\n")
-
-
-async def _write_snapshot(path: ZPath, data: dict, models: list | None = None) -> None:
-    proc = await asyncio.subprocess.create_subprocess_exec(
-        "git", "rev-parse", "HEAD", stdout=subprocess.PIPE, cwd=folder_paths.base_path
+def get_snapshot_path() -> Path | None:
+    manager_file_path = Path(
+        folder_paths.get_user_directory(), "default", "ComfyUI-Manager"
     )
-    stdout, _ = await proc.communicate()
-    if models is None:
-        print("Package => Writing models")
-        models = await _get_models()
+    return manager_file_path / "snapshots"
+
+
+async def _save_snapshot() -> dict[str, Any]:
+    save_snapshot_route = next(
+        (
+            route
+            for route in PromptServer.instance.routes
+            if route.path == "/snapshot/save"
+        ),
+        None,
+    )
+    if not save_snapshot_route:
+        raise RuntimeError("ComfyUI-Manager must be installed to save snapshot")
+    await save_snapshot_route.handler(None)
+    snapshot_path = get_snapshot_path()
+    if not snapshot_path.exists():
+        raise RuntimeError("Snapshot save failed")
+
+    most_recent = max(
+        snapshot_path.glob("*.json"), key=lambda x: x.stat().st_mtime, default=None
+    )
+    if not most_recent:
+        raise RuntimeError("Snapshot save failed")
+    with most_recent.open("r") as f:
+        return json.load(f)
+
+
+async def _write_snapshot(path: ZPath, data: dict, models: list) -> None:
+    snapshot = await _save_snapshot()
+    for package in list(snapshot["pips"]):
+        if any(
+            fnmatch(normalize_name(package.split("==")[0]), pat)
+            for pat in EXCLUDE_PACKAGES
+        ):
+            del snapshot["pips"][package]
     with path.joinpath("snapshot.json").open("w") as f:
-        data = {
-            "python": f"{sys.version_info.major}.{sys.version_info.minor}",
-            "comfyui": stdout.decode().strip(),
-            "models": models,
-            "custom_nodes": await _get_custom_nodes(),
-        }
-        f.write(json.dumps(data, indent=2))
+        snapshot.update(
+            {
+                "python": f"{sys.version_info.major}.{sys.version_info.minor}",
+                "models": models,
+            }
+        )
+        f.write(json.dumps(snapshot, indent=2))
 
 
 def _is_port_in_use(port: int | str, host="localhost"):
@@ -158,7 +168,7 @@ async def _get_models(
         if should_store:
             import bentoml
 
-            model_tag = f'cpack-model:{model_data["sha256"][:16]}'
+            model_tag = f"cpack-model:{model_data['sha256'][:16]}"
             try:
                 model = bentoml.models.get(model_tag)
             except bentoml.exceptions.NotFound:
@@ -174,47 +184,6 @@ async def _get_models(
     return models
 
 
-async def _get_custom_nodes() -> list:
-    print("Package => Writing custom nodes")
-    custom_nodes = os.path.join(folder_paths.base_path, "custom_nodes")
-    coros = []
-
-    async def get_node_info(subdir: Path) -> dict:
-        proc = await asyncio.subprocess.create_subprocess_exec(
-            "git",
-            "config",
-            "--get",
-            "remote.origin.url",
-            cwd=subdir,
-            stdout=subprocess.PIPE,
-        )
-        stdout, _ = await proc.communicate()
-        url = stdout.decode().strip()
-
-        proc = await asyncio.subprocess.create_subprocess_exec(
-            "git",
-            "rev-parse",
-            "HEAD",
-            cwd=subdir,
-            stdout=subprocess.PIPE,
-        )
-        stdout, _ = await proc.communicate()
-        commit_hash = stdout.decode().strip()
-        return {
-            "url": url,
-            "commit_hash": commit_hash,
-            "disabled": subdir.name.endswith(".disabled"),
-            "path": str(subdir.relative_to(custom_nodes)),
-        }
-
-    for subdir in Path(custom_nodes).iterdir():
-        if not subdir.is_dir() or not subdir.joinpath(".git").exists():
-            continue
-        coros.append(get_node_info(subdir))
-
-    return await asyncio.gather(*coros)
-
-
 async def _write_workflow(path: ZPath, data: dict) -> None:
     print("Package => Writing workflow")
     with path.joinpath("workflow_api.json").open("w") as f:
@@ -277,6 +246,8 @@ class DevServer:
 
     @classmethod
     def start(cls, workflow_api: dict, port: int = 3000):
+        from comfy_pack import __file__ as comfy_pack_file
+
         cls.stop()
 
         cls.port = port
@@ -285,7 +256,7 @@ class DevServer:
         with cls.run_dir.joinpath("workflow_api.json").open("w") as f:
             f.write(json.dumps(workflow_api, indent=2))
         shutil.copy(
-            Path(__file__).with_name("service.py"),
+            Path(comfy_pack_file).with_name("service.py"),
             cls.run_dir / "service.py",
         )
         shutil.copytree(COMFY_PACK_DIR, cls.run_dir / COMFY_PACK_DIR.name)
@@ -436,7 +407,7 @@ async def serve(request):
         )
 
 
-@PromptServer.instance.routes.post("/bentoml/serve/heartbeat")
+@PromptServer.instance.routes.get("/bentoml/serve/heartbeat")
 async def heartbeat(_):
     running = DevServer.feed_watch_dog()
 
@@ -462,14 +433,15 @@ async def _prepare_pack(
     working_dir: ZPath,
     data: dict,
     store_models: bool = False,
+    ensure_source: bool = True,
 ) -> None:
     model_filter = set(data.get("models", []))
     models = await _get_models(
         store_models=store_models,
         model_filter=model_filter,
+        ensure_source=ensure_source,
     )
 
-    await _write_requirements(working_dir, ["comfy-cli", "fastapi"])
     await _write_snapshot(working_dir, data, models)
     await _write_workflow(working_dir, data)
     await _write_inputs(working_dir, data)
@@ -535,14 +507,14 @@ async def build_bento_api(request):
 
     with tempfile.TemporaryDirectory(suffix="-bento", prefix="comfy-pack-") as temp_dir:
         temp_dir_path = Path(temp_dir)
-        await _prepare_pack(temp_dir_path, data, store_models=True)
+        await _prepare_pack(temp_dir_path, data, store_models=True, ensure_source=False)
 
         # create a bento
         try:
             bento = build_bento(
                 data["bento_name"],
                 temp_dir_path,
-                data.get("system_packages"),
+                system_packages=data.get("system_packages"),
             )
         except bentoml.exceptions.BentoMLException as e:
             return web.json_response(

nodes/nodes.py

@@ -3,13 +3,15 @@ import json
 import os
 import sys
 import shutil
+import zipfile
 
 import folder_paths
 import node_helpers
 import numpy as np
 import torch
-from PIL import Image, ImageOps, ImageSequence
+from PIL import Image, ImageOps, ImageSequence, PngImagePlugin
 from PIL.PngImagePlugin import PngInfo
+from io import BytesIO
 
 from .monkeypatch import set_bentoml_output
 
@@ -163,6 +165,86 @@ class OutputImage:
         return {"ui": {"images": results}}
 
 
+class OutputImageWithStringTxt:
+    COLOR = (142, 36, 170)
+
+    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": "cpack_output_"}),
+                "text": ("STRING", {"default": ""}),
+            },
+            "hidden": {
+                "prompt": "PROMPT",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+            },
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "save_images"
+    CPACK_NODE = True
+    OUTPUT_NODE = True
+
+    CATEGORY = "ComfyPack/output"
+    DESCRIPTION = "Saves the input images (and optional text) to your ComfyUI output directory."
+
+    def save_images(self, images, filename_prefix="cpack_output_", text="", prompt=None, extra_pnginfo=None):
+        filename_prefix += self.prefix_append
+        full_output_folder, filename, counter, subfolder, filename_prefix = (
+            get_save_image_path(
+                filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
+            )
+        )
+
+        base_counter = counter  # use for name zip
+        zip_filename = f"{filename}_batch_{base_counter:05}.zip"
+        zip_path = os.path.join(full_output_folder, zip_filename)
+
+        # create ZIP file
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for batch_number, image in enumerate(images):
+                # temp store img to RAM
+                i = 255.0 * image.cpu().numpy()
+                img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+
+                # write meta data
+                metadata = PngImagePlugin.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]))
+
+                # write img file to RAM buffer
+                img_buffer = BytesIO()
+                img.save(img_buffer, format="PNG", pnginfo=metadata, compress_level=self.compress_level)
+                img_buffer.seek(0)
+
+                # write img into ZIP file
+                image_filename = f"image_{batch_number:05}.png"
+                zipf.writestr(image_filename, img_buffer.read())
+
+                # write txt into ZIP file
+                text_filename = f"text_{batch_number:05}.txt"
+                zipf.writestr(text_filename, text)
+
+        # return zip as output
+        out = [{"filename": zip_filename, "subfolder": subfolder, "type": "zip"}]
+        return {
+            "ui": {
+                "zip": out,
+            }
+        }
+
+
 class ImageInput:
     COLOR = (142, 36, 170)
 
@@ -356,6 +438,7 @@ class AnyInput:
 NODE_CLASS_MAPPINGS = {
     "CPackOutputFile": OutputFile,
     "CPackOutputImage": OutputImage,
+    "CPackOutputZip": OutputImageWithStringTxt,
     "CPackInputImage": ImageInput,
     "CPackInputString": StringInput,
     "CPackInputInt": IntInput,
@@ -371,4 +454,5 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "CPackInputAny": "Any Input",
     "CPackOutputImage": "Image Output",
     "CPackOutputFile": "File Output",
+    "CPackOutputZip": "Zip Output(img + txt file)",
 }

pyproject.toml

@@ -8,7 +8,7 @@ authors = [{ name = "Frost Ming", email = "frost@bentoml.com" }]
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [
-    "bentoml>=1.3.13",
+    "bentoml>=1.3.21",
     "click>=8.1.7",
     "comfy-cli>=1.2.8",
 ]

requirements.txt

@@ -1,4 +1,4 @@
-bentoml
+bentoml>=1.3.21
 fastapi
 comfy-cli
 duckduckgo-search

src/comfy_pack/cli.py

@@ -5,6 +5,7 @@ import shutil
 import subprocess
 import sys
 import tempfile
+import zipfile
 from pathlib import Path
 
 import click
@@ -30,6 +31,7 @@ def _ensure_uv() -> None:
 
 
 @click.group()
+@click.version_option()
 def main():
     """comfy-pack CLI"""
     pass
@@ -55,27 +57,25 @@ def main():
 def init(dir: str, verbose: int):
     import os
 
-    from rich.console import Console
-
-    console = Console()
+    import rich
 
     # Check if directory path is valid
     try:
         install_dir = Path(dir).absolute()
         if install_dir.exists() and not install_dir.is_dir():
-            console.print(f"[red]Error: {dir} exists but is not a directory[/red]")
+            rich.print(f"[red]Error: {dir} exists but is not a directory[/red]")
             return 1
 
         # Check if directory is empty or contains ComfyUI
         if install_dir.exists():
             contents = list(install_dir.iterdir())
             if contents and not (install_dir / ".git").exists():
-                console.print(
+                rich.print(
                     f"[red]Error: Directory {dir} is not empty and doesn't appear to be a ComfyUI installation[/red]"
                 )
                 return 1
     except Exception as e:
-        console.print(f"[red]Error: Invalid directory path - {str(e)}[/red]")
+        rich.print(f"[red]Error: Invalid directory path - {str(e)}[/red]")
         return 1
 
     # Check git installation
@@ -241,7 +241,7 @@ def init(dir: str, verbose: int):
     name="unpack",
     help="Restore the ComfyUI workspace to specified directory",
 )
-@click.argument("cpack", type=click.Path(exists=True, dir_okay=False))
+@click.argument("cpack", type=click.Path(exists=True))
 @click.option(
     "--dir",
     "-d",
@@ -255,24 +255,49 @@ def init(dir: str, verbose: int):
     type=click.BOOL,
     is_flag=True,
 )
+@click.option(
+    "--no-models",
+    default=False,
+    type=click.BOOL,
+    is_flag=True,
+    help="Do not install models",
+)
+@click.option(
+    "--no-venv",
+    is_flag=True,
+    help="Do not create a virtual environment for ComfyUI",
+    default=False,
+)
 @click.option(
     "--verbose",
     "-v",
     count=True,
     help="Increase verbosity level (use multiple times for more verbosity)",
 )
-def unpack_cmd(cpack: str, dir: str, include_disabled_models: bool, verbose: int):
-    from rich.console import Console
+def unpack_cmd(
+    cpack: str,
+    dir: str,
+    include_disabled_models: bool,
+    no_models: bool,
+    no_venv: bool,
+    verbose: int,
+):
+    import rich
 
     from .package import install
 
-    console = Console()
+    install(
+        cpack,
+        dir,
+        verbose=verbose,
+        all_models=include_disabled_models,
+        prepare_models=not no_models,
+        no_venv=no_venv,
+    )
+    rich.print("\n[green]✓ ComfyUI Workspace is restored![/green]")
+    rich.print(f"{dir}")
 
-    install(cpack, dir, verbose=verbose, all_models=include_disabled_models)
-    console.print("\n[green]✓ ComfyUI Workspace is restored![/green]")
-    console.print(f"{dir}")
-
-    console.print(
+    rich.print(
         "\n[green] Next steps: [/green]\n"
         "1. Change directory to the restored workspace\n"
         "2. Source the virtual environment by running `source .venv/bin/activate`\n"
@@ -281,7 +306,7 @@ def unpack_cmd(cpack: str, dir: str, include_disabled_models: bool, verbose: int
 
 
 def _print_schema(schema, verbose: int = 0):
-    from rich.console import Console
+    import rich
     from rich.table import Table
 
     table = Table(title="")
@@ -312,7 +337,7 @@ def _print_schema(schema, verbose: int = 0):
             range_str,
         )
 
-    Console().print(table)
+    rich.print(table)
 
 
 @functools.lru_cache
@@ -340,8 +365,8 @@ def _get_cache_workspace(cpack: str):
 )
 @click.pass_context
 def run(ctx, cpack: str, output_dir: str, help: bool, verbose: int):
+    import rich
     from pydantic import ValidationError
-    from rich.console import Console
 
     from .utils import generate_input_model
 
@@ -349,35 +374,31 @@ def run(ctx, cpack: str, output_dir: str, help: bool, verbose: int):
         zip([k.lstrip("-").replace("-", "_") for k in ctx.args[::2]], ctx.args[1::2])
     )
 
-    console = Console()
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        pack_dir = Path(temp_dir) / ".cpack"
-        shutil.unpack_archive(cpack, pack_dir)
-        workflow = json.loads((pack_dir / "workflow_api.json").read_text())
+    with zipfile.ZipFile(cpack) as z:
+        workflow = json.loads(z.read("workflow_api.json"))
 
     input_model = generate_input_model(workflow)
 
     # If help is requested, show command help and input schema
     if help:
-        console.print(
+        rich.print(
             'Usage: comfy-pack run [OPTIONS] CPACK --input1 "value1" --input2 "value2" ...'
         )
-        console.print("Run a ComfyUI package with the given inputs:")
+        rich.print("Run a ComfyUI package with the given inputs:")
         _print_schema(input_model.model_json_schema(), verbose)
         return 0
 
     try:
         validated_data = input_model(**inputs)
-        console.print("[green]✓ Input is valid![/green]")
+        rich.print("[green]✓ Input is valid![/green]")
         for field, value in validated_data.model_dump().items():
-            console.print(f"{field}: {value}")
+            rich.print(f"{field}: {value}")
     except ValidationError as e:
-        console.print("[red]✗ Validation failed![/red]")
+        rich.print("[red]✗ Validation failed![/red]")
         for error in e.errors():
-            console.print(f"- {error['loc'][0]}: {error['msg']}")
+            rich.print(f"- {error['loc'][0]}: {error['msg']}")
 
-        console.print("\n[yellow]Expected inputs:[/yellow]")
+        rich.print("\n[yellow]Expected inputs:[/yellow]")
         _print_schema(input_model.model_json_schema(), verbose)
         return 1
 
@@ -404,6 +425,7 @@ def run(ctx, cpack: str, output_dir: str, help: bool, verbose: int):
             workflow,
             Path(output_dir).absolute(),
             verbose=verbose,
+            workspace=server.workspace,
             **validated_data.model_dump(),
         )
         console.print("\n[green]✓ Workflow is executed successfully![/green]")
@@ -420,9 +442,9 @@ def run(ctx, cpack: str, output_dir: str, help: bool, verbose: int):
 
 
 @main.command(name="build-bento")
+@click.argument("source")
 @click.option("--name", help="Name of the bento service")
 @click.option("--version", help="Version of the bento service")
-@click.argument("source")
 def bento_cmd(source: str, name: str | None, version: str | None):
     """Build a bento from the source, which can be either a .cpack.zip file or a bento tag."""
     import bentoml
@@ -439,10 +461,17 @@ def bento_cmd(source: str, name: str | None, version: str | None):
         else:
             existing_bento = bentoml.get(source)
             name = name or existing_bento.tag.name
-            shutil.copytree(existing_bento.path, temp_dir, dirs_exist_ok=True)
+            shutil.copytree(existing_bento.path_of("src"), temp_dir, dirs_exist_ok=True)
             build_config = BentoBuildConfig.from_bento_dir(
                 existing_bento.path_of("src")
             )
+            requirements_txt = Path(temp_dir) / "requirements.txt"
+            if (
+                requirements_txt.exists()
+                and "comfy-pack" not in requirements_txt.read_text()
+            ):
+                with open(requirements_txt, "a") as f:
+                    f.write("\ncomfy-pack")
             system_packages = build_config.docker.system_packages
             include_default_system_packages = False
 
@@ -453,3 +482,59 @@ def bento_cmd(source: str, name: str | None, version: str | None):
             system_packages=system_packages,
             include_default_system_packages=include_default_system_packages,
         )
+
+
+def setup_cloud_client(
+    ctx: click.Context, param: click.Parameter, value: str | None
+) -> str | None:
+    from bentoml._internal.configuration.containers import BentoMLContainer
+
+    if value:
+        BentoMLContainer.cloud_context.set(value)
+        os.environ["BENTOML_CLOUD_CONTEXT"] = value
+    return value
+
+
+@main.command()
+@click.argument("bento")
+@click.option(
+    "-w",
+    "--workspace",
+    type=click.Path(file_okay=False, path_type=Path),
+    default="workspace",
+    help="Workspace directory, defaults to './workspace'.",
+)
+@click.option("-v", "--verbose", count=True, help="Increase verbosity level")
+@click.option(
+    "--context",
+    help="BentoCloud context name.",
+    expose_value=False,
+    callback=setup_cloud_client,
+)
+def unpack_bento(bento: str, workspace: Path, verbose: int):
+    """Restore the ComfyUI workspace from a given bento."""
+    import bentoml
+
+    from .package import install
+
+    try:
+        bento_obj = bentoml.get(bento)
+    except bentoml.exceptions.NotFound:
+        click.echo(
+            f"Bento {bento} not found in the local repository, trying to pull from BentoCloud",
+            err=True,
+        )
+        bentoml.pull(bento)
+        bento_obj = bentoml.get(bento)
+
+    install(bento_obj.path_of("src"), workspace, verbose=verbose, prepare_models=False)
+
+    if os.name == "nt":
+        exe = "Scripts/python.exe"
+    else:
+        exe = "bin/python"
+    click.echo(
+        f"Workspace is ready at {workspace}\n"
+        f"You can start ComfyUI by running `cd {workspace} && .venv/{exe} main.py`",
+        color="green",
+    )

src/comfy_pack/package.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import json
 import os
 import shutil
@@ -25,28 +26,33 @@ COMFY_PACK_DIR = Path(__file__).parent
 def _clone_commit(url: str, commit: str, dir: Path, verbose: int = 0):
     stdout = None if verbose > 0 else subprocess.DEVNULL
     stderr = None if verbose > 1 else subprocess.DEVNULL
+    env = {**os.environ, "GIT_TERMINAL_PROMPT": "0"}
     subprocess.check_call(
         ["git", "clone", "--recurse-submodules", "--filter=blob:none", url, dir],
         stdout=stdout,
         stderr=stderr,
+        env=env,
     )
     subprocess.check_call(
         ["git", "fetch", "-q", url, commit],
         cwd=dir,
         stdout=stdout,
         stderr=stderr,
+        env=env,
     )
     subprocess.check_call(
         ["git", "checkout", "FETCH_HEAD"],
         cwd=dir,
         stdout=stdout,
         stderr=stderr,
+        env=env,
     )
     subprocess.check_call(
         ["git", "submodule", "update", "--init", "--recursive"],
         cwd=dir,
         stdout=stdout,
         stderr=stderr,
+        env=env,
     )
 
 
@@ -61,6 +67,18 @@ def install_comfyui(snapshot, workspace: Path, verbose: int = 0):
                 return
         shutil.rmtree(workspace)
     _clone_commit(COMFYUI_REPO, comfyui_commit, workspace, verbose=verbose)
+    manager_node = next(
+        url for url in snapshot.get("git_custom_nodes", {}) if "ComfyUI-Manager" in url
+    )
+    if manager_node:
+        manager_commit = snapshot["git_custom_nodes"][manager_node]["hash"].strip()
+        print("Installing ComfyUI-Manager")
+        _clone_commit(
+            manager_node,
+            manager_commit,
+            workspace / "custom_nodes" / "ComfyUI-Manager",
+            verbose=verbose,
+        )
     with open(workspace / ".DONE", "w") as f:
         f.write(comfyui_commit)
 
@@ -83,6 +101,7 @@ def install_custom_modules(snapshot, workspace: Path, verbose: int = 0):
                     continue
             shutil.rmtree(module_dir)
 
+        print(f"Installing custom node {url}")
         commit_hash = module["commit_hash"]
         _clone_commit(url, commit_hash, module_dir, verbose=verbose)
 
@@ -117,39 +136,39 @@ def install_custom_modules(snapshot, workspace: Path, verbose: int = 0):
 
 
 def install_dependencies(
-    snapshot: dict,
+    python_version: str,
     req_file: str,
     workspace: Path,
     verbose: int = 0,
+    no_deps: bool = False,
+    no_venv: bool = False,
 ):
     print("Installing Python dependencies")
-    python_version = snapshot["python"]
     stdout = None if verbose > 0 else subprocess.DEVNULL
     stderr = None if verbose > 1 else subprocess.DEVNULL
-
-    subprocess.check_call(
-        ["uv", "python", "install", python_version],
-        cwd=workspace,
-        stdout=stdout,
-        stderr=stderr,
-    )
-    venv = workspace / ".venv"
-    if (venv / "DONE").exists():
-        return
-    venv_py = (
-        venv / "Scripts" / "python.exe" if os.name == "nt" else venv / "bin" / "python"
-    )
-    subprocess.check_call(
-        [
-            "uv",
-            "venv",
-            "--python",
-            python_version,
-            venv,
-        ],
-        stdout=stdout,
-        stderr=stderr,
-    )
+    if no_venv:
+        print("Using the current Python environment")
+        venv_py = Path(sys.executable)
+    else:
+        venv = workspace / ".venv"
+        if (venv / "DONE").exists():
+            return
+        venv_py = (
+            venv / "Scripts" / "python.exe"
+            if os.name == "nt"
+            else venv / "bin" / "python"
+        )
+        subprocess.check_call(
+            [
+                "uv",
+                "venv",
+                "--python",
+                python_version,
+                venv,
+            ],
+            stdout=stdout,
+            stderr=stderr,
+        )
     subprocess.check_call(
         [
             "uv",
@@ -172,19 +191,19 @@ def install_dependencies(
         str(venv_py),
         "-r",
         req_file,
-        "--no-deps",
     ]
-    if STRICT_MODE:
-        pass
-    else:
+    if not STRICT_MODE:
         install_cmd.extend(["--index-strategy", "unsafe-best-match"])
+    if no_deps:
+        install_cmd.append("--no-deps")
     subprocess.check_call(
         install_cmd,
         stdout=stdout,
         stderr=stderr,
     )
-    with open(venv / "DONE", "w") as f:
-        f.write("DONE")
+    if not no_venv:
+        with open(venv / "DONE", "w") as f:
+            f.write("DONE")
     return venv_py
 
 
@@ -379,52 +398,78 @@ def retrieve_models(
                 continue
 
 
+def _ensure_startup_script_path(workspace: Path) -> Path:
+    script_path = workspace / "user" / "default" / "ComfyUI-Manager" / "startup-scripts"
+    script_path.mkdir(parents=True, exist_ok=True)
+    return script_path
+
+
 def install(
     cpack: str | Path,
     workspace: str | Path = "workspace",
     preheat: bool = True,
+    prepare_models: bool = True,
     all_models: bool = False,
+    no_venv: bool = False,
     verbose: int = 0,
 ):
     workspace = Path(workspace)
+    cpack = Path(cpack)
     print(f"Installing package {cpack} to {workspace} (verbose={verbose})")
-    with tempfile.TemporaryDirectory() as temp_dir:
-        pack_dir = Path(temp_dir) / ".cpack"
-        shutil.unpack_archive(cpack, pack_dir)
+    with contextlib.ExitStack() as stack:
+        if cpack.is_file():
+            temp_dir = stack.enter_context(tempfile.TemporaryDirectory())
+            pack_dir = Path(temp_dir) / ".cpack"
+            shutil.unpack_archive(cpack, pack_dir)
+        else:
+            pack_dir = cpack
         snapshot = json.loads((pack_dir / "snapshot.json").read_text())
-        req_txt_file = pack_dir / "requirements.txt"
+        if "pips" not in snapshot:
+            raise RuntimeError(
+                "This cpack is generated by an old version of comfy-pack, "
+                "please use comfy-pack<0.4.0 to unpack it."
+            )
 
         install_comfyui(snapshot, workspace, verbose=verbose)
-        install_dependencies(snapshot, str(req_txt_file), workspace, verbose=verbose)
+        install_dependencies(
+            snapshot["python"],
+            str(workspace / "requirements.txt"),
+            workspace,
+            no_venv=no_venv,
+            verbose=verbose,
+        )
+        shutil.copy2(
+            (pack_dir / "snapshot.json"),
+            _ensure_startup_script_path(workspace) / "restore-snapshot.json",
+        )
 
         for f in (pack_dir / "input").glob("*"):
             if f.is_file():
                 shutil.copy(f, workspace / "input" / f.name)
             elif f.is_dir():
                 shutil.copytree(f, workspace / "input" / f.name, dirs_exist_ok=True)
+        if prepare_models:
+            retrieve_models(
+                snapshot,
+                workspace,
+                verbose=verbose,
+                download=False,
+            )
 
-        retrieve_models(
-            snapshot,
-            workspace,
-            verbose=verbose,
-            download=False,
-        )
-
-        install_custom_modules(snapshot, workspace, verbose=verbose)
         if preheat:
             from .run import ComfyUIServer
 
             with ComfyUIServer(
                 str(workspace),
                 verbose=verbose,
-                venv=str(workspace / ".venv"),
+                venv=str(workspace / ".venv") if not no_venv else None,
             ) as _:
                 pass
-
-        retrieve_models(snapshot, workspace, verbose=verbose, all_models=all_models)
+        if prepare_models:
+            retrieve_models(snapshot, workspace, verbose=verbose, all_models=all_models)
 
 
-required_files = ["snapshot.json", "requirements.txt"]
+required_files = ["snapshot.json"]
 
 
 def build_bento(
@@ -456,11 +501,14 @@ def build_bento(
         system_packages = system_packages or []
 
     shutil.copy2(Path(__file__).with_name("service.py"), source_dir / "service.py")
-    # Copy comfy-pack package
-    shutil.copytree(
-        COMFY_PACK_DIR, source_dir / COMFY_PACK_DIR.name, dirs_exist_ok=True
-    )
-    snapshot = json.loads((source_dir / "snapshot.json").read_text())
+    snapshot_text = (source_dir / "snapshot.json").read_text()
+    setup_script = source_dir / "setup_workspace.sh"
+    with Path(__file__).with_name("setup_workspace.sh").open() as f:
+        setup_script.write_text(f.read().replace("<SNAPSHOT>", snapshot_text))
+    # Make setup script executable in a cross-platform way
+    if os.name in ("posix", "mac"):
+        setup_script.chmod(setup_script.stat().st_mode | 0o755)
+    snapshot = json.loads(snapshot_text)
     return bentoml.build(
         "service:ComfyService",
         name=bento_name,
@@ -475,7 +523,10 @@ def build_bento(
         docker={
             "python_version": f"{sys.version_info.major}.{sys.version_info.minor}",
             "system_packages": system_packages,
-            "setup_script": Path(__file__).with_name("setup_workspace.py").as_posix(),
+            "setup_script": source_dir.joinpath("setup_workspace.sh").as_posix(),
+        },
+        python={
+            "lock_packages": True,
+            "packages": ["fastapi", "comfy-pack>=0.4.0a0"],
         },
-        python={"requirements_txt": "requirements.txt", "lock_packages": True},
     )

src/comfy_pack/run.py

@@ -81,7 +81,7 @@ class ComfyUIServer:
                 self.port = 8188
         else:
             self.port = port
-        self.venv = venv
+        self.venv = os.path.abspath(venv) if venv else None
 
     def start(self) -> None:
         """
@@ -206,6 +206,7 @@ def run_workflow(
     output_dir: Union[str, Path, None] = None,
     timeout: int = 300,
     verbose: int = 0,
+    workspace: str = ".",
     **kwargs: Any,
 ) -> Any:
     """
@@ -258,6 +259,8 @@ def run_workflow(
     command = [
         "comfy",
         "--skip-prompt",
+        "--workspace",
+        workspace,
         "run",
         "--workflow",
         workflow_file_path.as_posix(),

src/comfy_pack/service.py

@@ -40,7 +40,7 @@ def _get_workspace() -> Path:
     from bentoml._internal.configuration.containers import BentoMLContainer
 
     snapshot = BASE_DIR / "snapshot.json"
-    checksum = hashlib.md5(snapshot.read_bytes()).hexdigest()
+    checksum = hashlib.md5(snapshot.read_bytes().strip()).hexdigest()
     wp = (
         Path(BentoMLContainer.bentoml_home.get()) / "run" / "comfy_workspace" / checksum
     )
@@ -73,7 +73,7 @@ else:
     snapshot = {}
 
 
-@bentoml.mount_asgi_app(app, path="/comfy")
+@bentoml.asgi_app(app, path="/comfy")
 @bentoml.service(traffic={"timeout": REQUEST_TIMEOUT * 2}, resources={"gpu": 1})
 class ComfyService:
     def __init__(self):
@@ -122,19 +122,13 @@ class ComfyService:
             output_dir=ctx.temp_dir,
             timeout=REQUEST_TIMEOUT,
             verbose=verbose,
+            workspace=self.server.workspace if hasattr(self, "server") else ".",
             **kwargs,
         )
         if isinstance(ret, list):
             ret = ret[-1]
         return ret
 
-    @bentoml.on_shutdown
-    def on_shutdown(self):
-        logger.info("Shutting down")
-        if not EXISTING_COMFYUI_SERVER:
-            self.watch_thread.join()
-            logger.info("Watch thread finished")
-
     @bentoml.on_deployment
     @staticmethod
     def prepare_models():

src/comfy_pack/setup_workspace.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-# ruff: noqa: E402
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-virtualenv = os.environ.get("VIRTUAL_ENV")
-if virtualenv and "--reload" not in sys.argv:
-    print("Re-executing in virtualenv:", virtualenv)
-    venv_python = os.path.join(virtualenv, "bin/python3")
-    os.execl(venv_python, venv_python, *sys.argv, "--reload")
-
-# The script path is ./env/docker/setup_script
-SRC_DIR = Path(__file__).parent.parent.parent / "src"
-INPUT_DIR = SRC_DIR / "input"
-sys.path.append(str(SRC_DIR))
-
-
-def _get_workspace() -> tuple[Path, dict]:
-    import hashlib
-    import json
-
-    from bentoml._internal.configuration.containers import BentoMLContainer
-
-    snapshot = SRC_DIR / "snapshot.json"
-    checksum = hashlib.md5(snapshot.read_bytes()).hexdigest()
-    wp = (
-        Path(BentoMLContainer.bentoml_home.get()) / "run" / "comfy_workspace" / checksum
-    )
-    wp.parent.mkdir(parents=True, exist_ok=True)
-    return wp, json.loads(snapshot.read_text())
-
-
-def prepare_comfy_workspace():
-    import shutil
-
-    from comfy_pack.package import install_comfyui, install_custom_modules
-
-    verbose = int("BENTOML_DEBUG" in os.environ)
-    comfy_workspace, snapshot = _get_workspace()
-
-    if not comfy_workspace.joinpath(".DONE").exists():
-        if comfy_workspace.exists():
-            print("Removing existing workspace")
-            shutil.rmtree(comfy_workspace, ignore_errors=True)
-        install_comfyui(snapshot, comfy_workspace, verbose=verbose)
-
-        for f in INPUT_DIR.glob("*"):
-            if f.is_file():
-                shutil.copy(f, comfy_workspace / "input" / f.name)
-            elif f.is_dir():
-                shutil.copytree(f, comfy_workspace / "input" / f.name)
-
-        install_custom_modules(snapshot, comfy_workspace, verbose=verbose)
-        comfy_workspace.joinpath(".DONE").touch()
-        subprocess.run(
-            ["chown", "-R", "bentoml:bentoml", str(comfy_workspace)], check=True
-        )
-
-
-if __name__ == "__main__":
-    prepare_comfy_workspace()

src/comfy_pack/setup_workspace.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -eo pipefail
+
+CPACK=/tmp/bento-cpack
+mkdir -p "$CPACK"
+
+cat <<EOF | head -c -1 > "$CPACK"/snapshot.json
+<SNAPSHOT>
+EOF
+
+checksum=$(md5sum "$CPACK"/snapshot.json | awk '{print $1}')
+workspace="${BENTOML_HOME:-$HOME/bentoml}/run/comfy_workspace/${checksum}"
+
+if [ -n "$VIRTUAL_ENV" ]; then
+    # shellcheck disable=SC1091
+    source "$VIRTUAL_ENV"/bin/activate
+fi
+
+set -x
+comfy-pack unpack "$CPACK" -d "$workspace" --no-models --no-venv -v
+chown -R bentoml:bentoml "$workspace"
+set +x

src/comfy_pack/utils.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
 CPACK_OUTPUT_NODES = {
     "CPackOutputFile",
     "CPackOutputImage",
+    "CPackOutputZip"
 }
 
 CPACK_PATH_INPUT_NODES = {

web/main.js

@@ -247,7 +247,7 @@ class FileTreeList {
     try {
       const { workflow, output: workflow_api } = await app.graphToPrompt();
       const files = await this.getInputFiles(workflow, workflow_api);
-      
+
       // 预先将默认选中的文件添加到选中列表
       files.forEach(file => {
         const path = file.path || file;
@@ -255,14 +255,14 @@ class FileTreeList {
           this.state.toggle(path, true);
         }
       });
-      
+
       this.renderTree(this.buildTree(files));
-    
+
     // 更新所有父目录的状态
     this.container.querySelectorAll("[data-action='check-dir']").forEach(checkbox => {
       this.updateFolderState(checkbox);
     });
-    
+
     // 更新总数
     this.updateCount();
     } catch(e) {
@@ -282,12 +282,12 @@ class FileTreeList {
 
   buildTree(files) {
     const root = { name: 'root', children: {}, files: [] };
-    
+
     for (const file of files) {
       const filePath = file.path || file;
       const parts = filePath.split(/[\/\\]/);
       let current = root;
-      
+
       for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
         if (i === parts.length - 1) {
@@ -313,24 +313,24 @@ class FileTreeList {
         }
       }
     }
-    
+
     // 对目录按名称排序
     for (const dir in root.children) {
       root.children[dir].files.sort((a, b) => a.name.localeCompare(b.name));
     }
-    
+
     return root;
   }
 
   renderTree(node, level = 0) {
     const dirs = Object.values(node.children);
     const hasChildren = dirs.length > 0 || node.files.length > 0;
-    
+
     this.container.innerHTML = this.renderNode(node, true);
-    
+
     this.setupEventListeners();
     this.updateCount();
-  
+
   }
 
   renderNode(node, isRoot = false) {
@@ -354,35 +354,35 @@ class FileTreeList {
 
     if (hasChildren) {
       html += `<div class="cpack-tree-children" style="display: ${isRoot ? '' : 'none'}">`;
-      
+
       // 渲染子目录
       for (const dir of dirs) {
         html += this.renderNode(dir);
       }
-      
+
       // 渲染文件
       for (const file of node.files) {
         html += `
           <div class="cpack-tree-item">
             <label style="padding-left: 17px">
-              <input type="checkbox" name="files" value="${file.path}" 
+              <input type="checkbox" name="files" value="${file.path}"
                 ${this.state.isSelected(file.path) || file.checked ? 'checked' : ''} />
               <span>${file.name}</span>
-              ${file.badges ? file.badges.map(badge => 
-                `<span style="background: ${badge.color || '#00a67d33'}; 
-                  color: ${badge.textColor || '#00a67d'}; 
-                  padding: 2px 6px; 
-                  border-radius: 4px; 
-                  font-size: 0.8em; 
+              ${file.badges ? file.badges.map(badge =>
+                `<span style="background: ${badge.color || '#00a67d33'};
+                  color: ${badge.textColor || '#00a67d'};
+                  padding: 2px 6px;
+                  border-radius: 4px;
+                  font-size: 0.8em;
                   cursor: help;
-                  white-space: nowrap;" 
+                  white-space: nowrap;"
                   title="${badge.tooltip || ''}">${badge.text}</span>`
               ).join('') : ''}
             </label>
           </div>
         `;
       }
-      
+
       html += '</div>';
     }
 
@@ -422,7 +422,7 @@ class FileTreeList {
   }
 
   setupEventListeners() {
-    
+
 
     // 目录选择功能
     this.container.querySelectorAll("[data-action='check-dir']").forEach(checkbox => {
@@ -433,7 +433,7 @@ class FileTreeList {
           const childFiles = Array.from(children.querySelectorAll("input[name='files']"))
             .map(input => input.value);
           this.state.toggleMultiple(childFiles, e.target.checked);
-          
+
           // 更新UI
           children.querySelectorAll("input[type='checkbox']").forEach(child => {
             child.checked = e.target.checked;
@@ -442,7 +442,7 @@ class FileTreeList {
           }
           });
         }
-        
+
       });
     });
 
@@ -464,7 +464,7 @@ class FileTreeList {
     this.container.querySelectorAll("input[name='files']").forEach(checkbox => {
       checkbox.addEventListener('change', (e) => {
         this.state.toggle(e.target.value, e.target.checked);
-      
+
       // 更新父文件夹状态
       const parentFolder = checkbox.closest('.cpack-tree-children')
         ?.previousElementSibling
@@ -477,7 +477,7 @@ class FileTreeList {
   }
 
   updateCount() {
-    
+
     const countSpan = document.querySelector(`[data-files-count='${this.countId}']`);
     if (countSpan) {
       countSpan.textContent = this.state.getSelectedCount();
@@ -616,7 +616,7 @@ class ModelList {
     // 只返回用户选中的模型
     return Array.from(this.container.querySelectorAll("input[name='models']:checked"))
       .map(input => input.value);
-  
+
   }
 }
 
@@ -679,7 +679,7 @@ async function createPackModal() {
     const packageOptionsContainer = form.querySelector("#package-options-container");
     const packageOptions = new PackageOptions(form, "pack-models-list", "pack-files-list", true);
     packageOptionsContainer.innerHTML = packageOptions.getHtml();
-    
+
     packageOptions.init().then(() => {
       confirmButton.disabled = false;
     });
@@ -775,7 +775,7 @@ async function unpackAction() {
   content.innerHTML = `
     <div style="margin-bottom: 20px;">
       <p style="margin-bottom: 15px;">To unpack a workflow package, follow these steps:</p>
-      
+
       <div style="margin-bottom: 15px;">
         <p style="margin-bottom: 10px;">1. Install comfy-pack CLI:</p>
         <div class="cpack-copyable" style="margin: 10px 0;">
@@ -804,13 +804,13 @@ async function unpackAction() {
       const closeButton = document.createElement("button");
       closeButton.textContent = "Close";
       closeButton.className = "cpack-btn";
-      
+
       buttonContainer.appendChild(closeButton);
-      
+
       modal.appendChild(title);
       modal.appendChild(content);
       modal.appendChild(buttonContainer);
-      
+
       const { close } = createModal(modal);
       closeButton.onclick = close;
 }
@@ -1001,13 +1001,13 @@ class PackageOptions {
   async init() {
     const modelsList = this.container.querySelector(`#${this.modelsListId}`);
     const filesList = this.container.querySelector(`#${this.filesListId}`);
-    
+
     this.modelListComponent = new ModelList(modelsList, this.modelsListId);
     this.fileListComponent = new FileTreeList(filesList, this.filesListId);
 
     const addButton = this.container.querySelector("#add-button");
     const systemPackagesArray = this.container.querySelector("#system-packages-array");
-    
+
     addButton.addEventListener("click", (e) => {
       e.preventDefault();
       const row = document.createElement("div");
@@ -1063,7 +1063,7 @@ const buildForm = `
       <p style="font-size: 0.85em; color: #888; margin-top: 5px;">
         Get your API Token at <a href="https://cloud.bentoml.com/signup?from=comfy-pack" target="_blank" style="color: #00a67d;">cloud.bentoml.com</a>
       </p>
-  
+
     </div>
 
   </div>
@@ -1112,7 +1112,7 @@ function createBuildModal() {
     const packageOptionsContainer = form.querySelector("#package-options-container");
     const packageOptions = new PackageOptions(form, "build-models-list", "build-files-list", false);
     packageOptionsContainer.innerHTML = packageOptions.getHtml();
-    
+
     packageOptions.init().then(() => {
       confirmButton.disabled = false;
     });
@@ -1234,7 +1234,7 @@ async function createServeStatusModal(url) {
   // Start status checking
   const checkInterval = setInterval(async () => {
     try {
-      const resp = await api.fetchApi("/bentoml/serve/heartbeat", { method: "POST" });
+      const resp = await api.fetchApi("/bentoml/serve/heartbeat");
       const status = await resp.json();
       if (status.error) {
         title.textContent = "Server Error";