comfy-cli 1.7.0__tar.gz → 1.7.2__tar.gz

{comfy_cli-1.7.0 → comfy_cli-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-cli
-Version: 1.7.0
+Version: 1.7.2
 Summary: A CLI tool for installing and using ComfyUI.
 Maintainer-email: Yoland Yan <yoland@drip.art>, James Kwon <hongilkwon316@gmail.com>, Robin Huang <robin@drip.art>, "Dr.Lt.Data" <dr.lt.data@gmail.com>
 License: GPL-3.0-only
@@ -111,6 +111,9 @@ will simply update the comfy.yaml file to reflect the local setup
   pip install comfyui-manager==4.1b8          # specific version
   ```
 - `comfy --workspace=<path> install`: Install ComfyUI into `<path>/ComfyUI`.
+- `comfy install --fast-deps`: Use `uv` instead of `pip` for faster dependency resolution
+  during initial ComfyUI installation. comfy-cli's built-in resolver compiles all requirements (core + custom nodes)
+  into a single lockfile and installs from it. Also handles GPU-specific PyTorch wheel selection automatically.
 - For `comfy install`, if no path specification like `--workspace, --recent, or --here` is provided, it will be implicitly installed in `<HOME>/comfy`.
 
 #### Python environment handling
@@ -257,8 +260,9 @@ comfy node [show|simple-show] [installed|enabled|not-installed|disabled|all|snap
 #### Unified Dependency Resolution (--uv-compile)
 
 Requires ComfyUI-Manager v4.1+. Instead of installing dependencies per-node with
-`pip install`, `--uv-compile` batch-resolves all custom node dependencies via
-`uv pip compile` to avoid version conflicts.
+`pip install`, `--uv-compile` delegates to ComfyUI-Manager's unified resolver which batch-resolves
+all custom node dependencies via `uv pip compile` with **cross-node conflict detection** —
+it can identify which node packs have incompatible dependencies and why.
 
 - Install with unified resolution:
 
@@ -280,6 +284,23 @@ Requires ComfyUI-Manager v4.1+. Instead of installing dependencies per-node with
 
   `comfy node install comfyui-impact-pack --no-uv-compile`
 
+#### --fast-deps vs --uv-compile
+
+Both flags use `uv` for faster dependency resolution, but they work differently:
+
+|                       | `--fast-deps`                                   | `--uv-compile`                                |
+|-----------------------|-------------------------------------------------|-----------------------------------------------|
+| **Resolver**          | comfy-cli built-in (`DependencyCompiler`)       | ComfyUI-Manager (`UnifiedDepResolver`)        |
+| **Scope**             | `comfy install`, `comfy node install/reinstall` | Custom node commands only                     |
+| **Conflict handling** | Interactive prompt to pick a version            | Automatic detection with node attribution     |
+| **Config default**    | No                                              | Yes (`comfy manager uv-compile-default true`) |
+| **Requires**          | Only `uv`                                       | ComfyUI-Manager v4.1+                         |
+
+**When to use which:**
+- For initial ComfyUI installation with uv: `comfy install --fast-deps`
+- For custom node management with Manager v4.1+: `--uv-compile` (recommended)
+- For custom node management with older Manager: `--fast-deps`
+
 #### Bisect custom nodes
 
 If you encounter bugs only with custom nodes enabled, and want to find out which custom node(s) causes the bug,

{comfy_cli-1.7.0 → comfy_cli-1.7.2}/README.md

@@ -66,6 +66,9 @@ will simply update the comfy.yaml file to reflect the local setup
   pip install comfyui-manager==4.1b8          # specific version
   ```
 - `comfy --workspace=<path> install`: Install ComfyUI into `<path>/ComfyUI`.
+- `comfy install --fast-deps`: Use `uv` instead of `pip` for faster dependency resolution
+  during initial ComfyUI installation. comfy-cli's built-in resolver compiles all requirements (core + custom nodes)
+  into a single lockfile and installs from it. Also handles GPU-specific PyTorch wheel selection automatically.
 - For `comfy install`, if no path specification like `--workspace, --recent, or --here` is provided, it will be implicitly installed in `<HOME>/comfy`.
 
 #### Python environment handling
@@ -212,8 +215,9 @@ comfy node [show|simple-show] [installed|enabled|not-installed|disabled|all|snap
 #### Unified Dependency Resolution (--uv-compile)
 
 Requires ComfyUI-Manager v4.1+. Instead of installing dependencies per-node with
-`pip install`, `--uv-compile` batch-resolves all custom node dependencies via
-`uv pip compile` to avoid version conflicts.
+`pip install`, `--uv-compile` delegates to ComfyUI-Manager's unified resolver which batch-resolves
+all custom node dependencies via `uv pip compile` with **cross-node conflict detection** —
+it can identify which node packs have incompatible dependencies and why.
 
 - Install with unified resolution:
 
@@ -235,6 +239,23 @@ Requires ComfyUI-Manager v4.1+. Instead of installing dependencies per-node with
 
   `comfy node install comfyui-impact-pack --no-uv-compile`
 
+#### --fast-deps vs --uv-compile
+
+Both flags use `uv` for faster dependency resolution, but they work differently:
+
+|                       | `--fast-deps`                                   | `--uv-compile`                                |
+|-----------------------|-------------------------------------------------|-----------------------------------------------|
+| **Resolver**          | comfy-cli built-in (`DependencyCompiler`)       | ComfyUI-Manager (`UnifiedDepResolver`)        |
+| **Scope**             | `comfy install`, `comfy node install/reinstall` | Custom node commands only                     |
+| **Conflict handling** | Interactive prompt to pick a version            | Automatic detection with node attribution     |
+| **Config default**    | No                                              | Yes (`comfy manager uv-compile-default true`) |
+| **Requires**          | Only `uv`                                       | ComfyUI-Manager v4.1+                         |
+
+**When to use which:**
+- For initial ComfyUI installation with uv: `comfy install --fast-deps`
+- For custom node management with Manager v4.1+: `--uv-compile` (recommended)
+- For custom node management with older Manager: `--fast-deps`
+
 #### Bisect custom nodes
 
 If you encounter bugs only with custom nodes enabled, and want to find out which custom node(s) causes the bug,

{comfy_cli-1.7.0 → comfy_cli-1.7.2}/comfy_cli/cmdline.py

@@ -10,7 +10,7 @@ from rich import print as rprint
 from rich.console import Console
 
 from comfy_cli import constants, env_checker, logging, tracking, ui, utils
-from comfy_cli.command import custom_nodes, pr_command
+from comfy_cli.command import code_search, custom_nodes, pr_command
 from comfy_cli.command import install as install_inner
 from comfy_cli.command import run as run_inner
 from comfy_cli.command.install import validate_version
@@ -18,6 +18,7 @@ from comfy_cli.command.launch import launch as launch_command
 from comfy_cli.command.models import models as models_command
 from comfy_cli.config_manager import ConfigManager
 from comfy_cli.constants import GPU_OPTION, CUDAVersion, ROCmVersion
+from comfy_cli.cuda_detect import DEFAULT_CUDA_TAG, detect_cuda_driver_version, resolve_cuda_wheel
 from comfy_cli.env_checker import EnvChecker
 from comfy_cli.resolve_python import resolve_workspace_python
 from comfy_cli.standalone import StandalonePython
@@ -142,6 +143,43 @@ def validate_commit_and_version(commit: str | None, ctx: typer.Context) -> str |
     return commit
 
 
+def _resolve_cuda(
+    gpu: GPU_OPTION | None,
+    cuda_version: CUDAVersion | None,
+) -> tuple[CUDAVersion | None, str | None]:
+    """Resolve the CUDA wheel tag for an NVIDIA install.
+
+    Returns (cuda_version_enum_or_None, cuda_tag_string_or_None).
+    When the user passed an explicit --cuda-version, that is used as-is.
+    Otherwise auto-detection is attempted.
+    """
+    if gpu != GPU_OPTION.NVIDIA:
+        return cuda_version, None
+
+    if cuda_version is not None:
+        tag = f"cu{cuda_version.value.replace('.', '')}"
+        rprint(f"[bold]Using explicit CUDA version:[/bold] {cuda_version.value} ({tag})")
+        return cuda_version, tag
+
+    drv = detect_cuda_driver_version()
+    if drv is not None:
+        tag = resolve_cuda_wheel(drv)
+        if tag is not None:
+            rprint(f"[bold green]Detected CUDA driver version:[/bold green] {drv[0]}.{drv[1]} → using {tag}")
+            return None, tag
+        rprint(
+            f"[bold yellow]Warning:[/bold yellow] CUDA driver {drv[0]}.{drv[1]} is too old for any known PyTorch wheel. "
+            f"Falling back to {DEFAULT_CUDA_TAG}. Use `--cuda-version` to override."
+        )
+        return None, DEFAULT_CUDA_TAG
+
+    rprint(
+        f"[bold yellow]Warning:[/bold yellow] Could not detect CUDA driver version. "
+        f"Falling back to {DEFAULT_CUDA_TAG}. Use `--cuda-version` to override."
+    )
+    return None, DEFAULT_CUDA_TAG
+
+
 @app.command(help="Download and install ComfyUI and ComfyUI-Manager")
 @tracking.track_command()
 def install(
@@ -186,7 +224,7 @@ def install(
             callback=g_gpu_exclusivity.validate,
         ),
     ] = None,
-    cuda_version: Annotated[CUDAVersion, typer.Option(show_default=True)] = CUDAVersion.v12_6,
+    cuda_version: Annotated[CUDAVersion | None, typer.Option(show_default=False)] = None,
     rocm_version: Annotated[ROCmVersion, typer.Option(show_default=True)] = ROCmVersion.v6_3,
     amd: Annotated[
         bool | None,
@@ -229,7 +267,7 @@ def install(
         typer.Option(
             "--fast-deps",
             show_default=False,
-            help="Use new fast dependency installer",
+            help="Use uv instead of pip for dependency resolution (comfy-cli built-in resolver)",
         ),
     ] = False,
     pr: Annotated[
@@ -245,7 +283,7 @@ def install(
 
     comfy_path, _ = workspace_manager.get_workspace_path()
 
-    is_comfy_installed_at_path, repo_dir = check_comfy_repo(comfy_path)
+    is_comfy_installed_at_path, resolved_path = check_comfy_repo(comfy_path)
     if is_comfy_installed_at_path and not restore:
         rprint(f"[bold red]ComfyUI is already installed at the specified path:[/bold red] {comfy_path}\n")
         rprint(
@@ -253,8 +291,8 @@ def install(
         )
         raise typer.Exit(code=1)
 
-    if repo_dir is not None:
-        comfy_path = str(repo_dir.working_dir)
+    if resolved_path is not None:
+        comfy_path = resolved_path
 
     if checker.python_version.major < 3 or checker.python_version.minor < 9:
         rprint("[bold red]Python version 3.9 or higher is required to run ComfyUI.[/bold red]")
@@ -276,6 +314,7 @@ def install(
             version=version,
             gpu=None,
             cuda_version=cuda_version,
+            cuda_tag=None,
             rocm_version=rocm_version,
             plat=platform,
             skip_torch_or_directml=skip_torch_or_directml,
@@ -321,6 +360,8 @@ def install(
         )
         raise typer.Exit(code=1)
 
+    cuda_version, cuda_tag = _resolve_cuda(gpu, cuda_version) if not skip_torch_or_directml else (cuda_version, None)
+
     install_inner.execute(
         url,
         comfy_path,
@@ -330,6 +371,7 @@ def install(
         gpu=gpu,
         version=version,
         cuda_version=cuda_version,
+        cuda_tag=cuda_tag,
         rocm_version=rocm_version,
         plat=platform,
         skip_torch_or_directml=skip_torch_or_directml,
@@ -374,7 +416,10 @@ def update(
             check=True,
         )
 
-    custom_nodes.command.update_node_id_cache()
+    try:
+        custom_nodes.command.update_node_id_cache()
+    except (FileNotFoundError, subprocess.CalledProcessError) as e:
+        rprint(f"[yellow]Failed to update node id cache: {e}[/yellow]")
 
 
 @app.command(help="Run API workflow file using the ComfyUI launched by `comfy launch --background`")
@@ -487,7 +532,7 @@ def set_default(
         )
         raise typer.Exit(code=1)
 
-    is_comfy_repo, comfy_repo = check_comfy_repo(comfy_path)
+    is_comfy_repo, resolved_path = check_comfy_repo(comfy_path)
     if not is_comfy_repo:
         rprint(
             f"\nSpecified path is not a ComfyUI path: {comfy_path}.\n",
@@ -495,7 +540,7 @@ def set_default(
         )
         raise typer.Exit(code=1)
 
-    comfy_path = comfy_repo.working_dir
+    comfy_path = resolved_path
 
     rprint(f"Specified path is set as default ComfyUI path: {comfy_path} ")
     workspace_manager.set_default_workspace(comfy_path)
@@ -643,4 +688,7 @@ app.add_typer(custom_nodes.manager_app, name="manager", help="Manage ComfyUI-Man
 
 app.add_typer(pr_command.app, name="pr-cache", help="Manage PR cache.")
 
+app.add_typer(code_search.app, name="code-search", help="Search code across ComfyUI repositories.")
+app.add_typer(code_search.app, name="cs", hidden=True)
+
 app.add_typer(tracking.app, name="tracking", help="Manage analytics tracking settings.")

comfy_cli-1.7.2/comfy_cli/command/code_search.py

@@ -0,0 +1,157 @@
+"""CLI commands for searching code across ComfyUI repositories."""
+
+import json
+import re
+from typing import Annotated
+from urllib.parse import quote
+
+import requests
+import typer
+from rich.console import Console
+from rich.text import Text
+
+from comfy_cli import tracking
+
+app = typer.Typer()
+console = Console()
+
+API_URL = "https://comfy-codesearch.vercel.app/api/search/code"
+DEFAULT_COUNT = 20
+REQUEST_TIMEOUT = 30
+
+
+def _build_query(query: str, repo: str | None, count: int) -> str:
+    parts = []
+    if repo:
+        if "/" not in repo:
+            repo = f"Comfy-Org/{repo}"
+        parts.append(f"repo:^{re.escape(repo)}$")
+    parts.append(f"count:{count}")
+    parts.append(query)
+    return " ".join(parts)
+
+
+def _fetch_results(query: str) -> dict:
+    response = requests.get(API_URL, params={"query": query}, timeout=REQUEST_TIMEOUT)
+    response.raise_for_status()
+    return response.json()
+
+
+def _format_results(search: dict) -> list[dict]:
+    raw_results = search.get("results", {}).get("results", [])
+    formatted = []
+    for result in raw_results:
+        repo_info = result.get("repository") or {}
+        repo_name = repo_info.get("name", "")
+        clean_name = repo_name.removeprefix("github.com/")
+
+        file_info = result.get("file") or {}
+        file_path = file_info.get("path", "")
+
+        if not clean_name or not file_path:
+            continue
+
+        default_branch = repo_info.get("defaultBranch") or {}
+        branch_name = default_branch.get("displayName", "main")
+        commit_hash = (default_branch.get("target") or {}).get("commit", {}).get("oid", "")
+        ref = commit_hash or branch_name
+
+        line_matches = result.get("lineMatches") or []
+        matches = []
+        if line_matches:
+            encoded_path = quote(file_path, safe="/")
+            base_url = f"https://github.com/{clean_name}/blob/{ref}/{encoded_path}"
+            for m in line_matches:
+                line = m.get("lineNumber", 0) + 1
+                preview = m.get("preview", "").rstrip()
+                matches.append({"line": line, "preview": preview, "url": f"{base_url}#L{line}"})
+
+        formatted.append(
+            {
+                "repository": clean_name,
+                "file": file_path,
+                "branch": branch_name,
+                "commit": commit_hash,
+                "matches": matches,
+            }
+        )
+
+    return formatted
+
+
+def _get_stats(search: dict) -> dict:
+    return {
+        "approximate_count": search.get("stats", {}).get("approximateResultCount", "0"),
+        "match_count": search.get("results", {}).get("matchCount", 0),
+        "limit_hit": search.get("results", {}).get("limitHit", False),
+    }
+
+
+def _print_results(results: list[dict], stats: dict, json_output: bool) -> None:
+    if json_output:
+        print(json.dumps({"stats": stats, "results": results}, indent=2))
+        return
+
+    if not results:
+        console.print("[yellow]No results found.[/yellow]")
+        return
+
+    for file_result in results:
+        header = Text()
+        header.append(file_result["repository"], style="bold cyan")
+        header.append(" / ", style="dim")
+        header.append(file_result["file"], style="bold")
+        console.print(header)
+
+        for match in file_result["matches"]:
+            line_text = Text()
+            line_text.append(f"  L{match['line']:>5}", style="green")
+            line_text.append(f"  {match['preview']}")
+            console.print(line_text)
+            console.print(f"        [dim]{match['url']}[/dim]")
+
+        console.print()
+
+    limit_msg = " (limit hit — use --count to fetch more)" if stats.get("limit_hit") else ""
+    console.print(
+        f"[dim]{stats['approximate_count']} approximate results, {stats['match_count']} matches returned{limit_msg}[/dim]"
+    )
+
+
+@app.callback(invoke_without_command=True)
+@tracking.track_command()
+def code_search(
+    query: Annotated[str, typer.Argument(help="Search query (supports Sourcegraph syntax)")],
+    repo: Annotated[
+        str | None,
+        typer.Option("--repo", "-r", help="Filter by repository (e.g. ComfyUI, Comfy-Org/ComfyUI)"),
+    ] = None,
+    count: Annotated[
+        int,
+        typer.Option("--count", "-n", help="Maximum number of results"),
+    ] = DEFAULT_COUNT,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", "-j", help="Output results as JSON"),
+    ] = False,
+):
+    """Search code across ComfyUI repositories."""
+    built_query = _build_query(query, repo, count)
+
+    try:
+        data = _fetch_results(built_query)
+    except requests.ConnectionError:
+        console.print("[bold red]Error: Could not connect to the code search service.[/bold red]")
+        raise typer.Exit(code=1)
+    except requests.Timeout:
+        console.print("[bold red]Error: Request timed out.[/bold red]")
+        raise typer.Exit(code=1)
+    except requests.HTTPError as e:
+        status = e.response.status_code if e.response is not None else "unknown"
+        console.print(f"[bold red]Error: HTTP {status}[/bold red]")
+        raise typer.Exit(code=1)
+
+    search = data.get("data", {}).get("search", {})
+    results = _format_results(search)
+    stats = _get_stats(search)
+    _print_results(results, stats, json_output=json_output)

{comfy_cli-1.7.0 → comfy_cli-1.7.2}/comfy_cli/command/custom_nodes/bisect_custom_nodes.py

@@ -122,6 +122,22 @@ set of nodes to test: {len(self.active)}
 {active_list}"""
 
 
+def parse_cm_output(cm_output: str, pinned_nodes: set[str] | None = None) -> list[str]:
+    """Parse cm_cli simple-show output into a list of node names.
+
+    cm_cli simple-show always formats node entries as ``name@version``
+    (see ComfyUI-Manager cm_cli show_list).  We whitelist on the ``@``
+    separator so any progress/status lines are ignored regardless of
+    their prefix.
+    """
+    pinned = pinned_nodes or set()
+    return [
+        stripped
+        for line in cm_output.strip().split("\n")
+        if (stripped := line.strip()) and "@" in stripped and stripped not in pinned
+    ]
+
+
 @bisect_app.command(
     help="Start a new bisect session with optionally pinned nodes to always enable, and optional ComfyUI launch args."
     + "?[--pinned-nodes PINNED_NODES]"
@@ -145,11 +161,7 @@ def start(
         typer.echo("Failed to fetch the list of nodes.")
         raise typer.Exit()
 
-    nodes_list = [
-        line.strip()
-        for line in cm_output.strip().split("\n")
-        if not line.startswith("FETCH DATA") and line.strip() not in pinned_nodes
-    ]
+    nodes_list = parse_cm_output(cm_output, pinned_nodes)
     state = BisectState(
         status="running",
         all=nodes_list,

{comfy_cli-1.7.0 → comfy_cli-1.7.2}/comfy_cli/command/install.py

@@ -18,6 +18,7 @@ from comfy_cli import constants, ui
 from comfy_cli.command.custom_nodes.command import update_node_id_cache
 from comfy_cli.command.github.pr_info import PRInfo
 from comfy_cli.constants import GPU_OPTION
+from comfy_cli.cuda_detect import DEFAULT_CUDA_TAG
 from comfy_cli.git_utils import checkout_pr, git_checkout_tag
 from comfy_cli.resolve_python import ensure_workspace_python
 from comfy_cli.uv import DependencyCompiler
@@ -45,11 +46,12 @@ def pip_install_comfyui_dependencies(
     repo_dir,
     gpu: GPU_OPTION,
     plat: constants.OS,
-    cuda_version: constants.CUDAVersion,
+    cuda_version: constants.CUDAVersion | None,
     skip_torch_or_directml: bool,
     skip_requirement: bool,
     python: str = sys.executable,
     rocm_version: constants.ROCmVersion = constants.ROCmVersion.v6_3,
+    cuda_tag: str | None = None,
 ):
     os.chdir(repo_dir)
 
@@ -63,7 +65,8 @@ def pip_install_comfyui_dependencies(
 
         # install torch for NVIDIA
         if gpu == GPU_OPTION.NVIDIA:
-            cuda_tag = f"cu{cuda_version.value.replace('.', '')}"
+            if cuda_tag is None:
+                cuda_tag = f"cu{cuda_version.value.replace('.', '')}" if cuda_version else DEFAULT_CUDA_TAG
             result = _pip_install_torch(python, ["--index-url", f"https://download.pytorch.org/whl/{cuda_tag}"])
 
         # install torch for Intel Arc GPUs (upstream torch xpu)
@@ -147,7 +150,8 @@ def execute(
     version: str,
     commit: str | None = None,
     gpu: constants.GPU_OPTION = None,
-    cuda_version: constants.CUDAVersion = constants.CUDAVersion.v12_6,
+    cuda_version: constants.CUDAVersion | None = None,
+    cuda_tag: str | None = None,
     rocm_version: constants.ROCmVersion = constants.ROCmVersion.v6_3,
     plat: constants.OS = None,
     skip_torch_or_directml: bool = False,
@@ -227,6 +231,7 @@ def execute(
             skip_requirement,
             python=python,
             rocm_version=rocm_version,
+            cuda_tag=cuda_tag,
         )
 
     WorkspaceManager().set_recent_workspace(repo_dir)
@@ -256,11 +261,19 @@ def execute(
             # Workspace venv needs uv bootstrapped; for the global Python
             # uv is already available as a comfy-cli dependency.
             DependencyCompiler.Install_Build_Deps(executable=python)
+        if cuda_tag:
+            # DependencyCompiler expects a dotted version like "13.0", not a tag like "cu130"
+            digits = cuda_tag[2:]
+            resolved_cuda = f"{digits[:2]}.{digits[2:]}"
+        elif cuda_version:
+            resolved_cuda = cuda_version.value
+        else:
+            resolved_cuda = None
         depComp = DependencyCompiler(
             cwd=repo_dir,
             executable=python,
             gpu=gpu,
-            cuda_version=cuda_version.value,
+            cuda_version=resolved_cuda,
             rocm_version=rocm_version.value,
             skip_torch=skip_torch_or_directml,
         )
@@ -463,8 +476,16 @@ def get_latest_release(repo_owner: str, repo_name: str) -> GithubRelease | None:
     """
     url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases/latest"
 
+    headers = {}
+    if github_token := os.getenv("GITHUB_TOKEN"):
+        headers["Authorization"] = f"Bearer {github_token}"
+
     try:
-        response = requests.get(url, timeout=5)
+        response = requests.get(url, headers=headers, timeout=5)
+
+        if response.status_code in (403, 429):
+            handle_github_rate_limit(response)
+
         response.raise_for_status()
 
         data = response.json()

{comfy_cli-1.7.0 → comfy_cli-1.7.2}/comfy_cli/command/models/models.py

@@ -1,6 +1,7 @@
 import contextlib
 import os
 import pathlib
+import time
 from typing import Annotated
 from urllib.parse import parse_qs, unquote, urlparse
 
@@ -33,6 +34,18 @@ def get_workspace() -> pathlib.Path:
     return pathlib.Path(workspace_manager.workspace_path)
 
 
+def _format_elapsed(seconds: float) -> str:
+    """Format elapsed seconds into a human-readable string."""
+    rounded = round(seconds, 1)
+    if rounded < 60:
+        return f"{rounded:.1f}s"
+    minutes, secs = divmod(int(rounded), 60)
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes}m {secs}s"
+
+
 def potentially_strip_param_url(path_name: str) -> str:
     return path_name.split("?")[0]
 
@@ -219,6 +232,14 @@ def download(
             show_default=False,
         ),
     ] = None,
+    downloader: Annotated[
+        str | None,
+        typer.Option(
+            "--downloader",
+            help="Download backend: 'httpx' (default) or 'aria2' (requires aria2 RPC server).",
+            show_default=False,
+        ),
+    ] = None,
 ):
     if relative_path is not None:
         relative_path = os.path.expanduser(relative_path)
@@ -233,6 +254,8 @@ def download(
         constants.HF_API_TOKEN_ENV_KEY, constants.HF_API_TOKEN_KEY, set_hf_api_token
     )
 
+    resolved_downloader = downloader or config_manager.get(constants.CONFIG_KEY_DEFAULT_DOWNLOADER) or "httpx"
+
     is_civitai_model_url, is_civitai_api_url, model_id, version_id = check_civitai_url(url)
     is_huggingface_url, repo_id, hf_filename, hf_folder_name, hf_branch_name = check_huggingface_url(url)
 
@@ -297,6 +320,8 @@ def download(
         print(f"[bold red]File already exists: {local_filepath}[/bold red]")
         return
 
+    start_time = time.monotonic()
+
     if is_huggingface_url and check_unauthorized(url, headers):
         if hf_api_token is None:
             print(
@@ -329,7 +354,10 @@ def download(
             print(f"Model downloaded successfully to: {output_path}")
     else:
         print(f"Start downloading URL: {url} into {local_filepath}")
-        download_file(url, local_filepath, headers)
+        download_file(url, local_filepath, headers, downloader=resolved_downloader)
+
+    elapsed = time.monotonic() - start_time
+    print(f"Done in {_format_elapsed(elapsed)}")
 
 
 @app.command()

{comfy_cli-1.7.0 → comfy_cli-1.7.2}/comfy_cli/constants.py

@@ -50,6 +50,10 @@ CIVITAI_API_TOKEN_ENV_KEY = "CIVITAI_API_TOKEN"
 HF_API_TOKEN_KEY = "hf_api_token"
 HF_API_TOKEN_ENV_KEY = "HF_API_TOKEN"
 
+ARIA2_SERVER_ENV_KEY = "COMFYUI_MANAGER_ARIA2_SERVER"
+ARIA2_SECRET_ENV_KEY = "COMFYUI_MANAGER_ARIA2_SECRET"
+CONFIG_KEY_DEFAULT_DOWNLOADER = "default_downloader"
+
 DEFAULT_TRACKING_VALUE = True
 
 COMFY_LOCK_YAML_FILE = "comfy.lock.yaml"
@@ -72,7 +76,9 @@ COMFY_ORIGIN_URL_CHOICES = {
 
 
 class CUDAVersion(str, Enum):
+    v13_0 = "13.0"
     v12_9 = "12.9"
+    v12_8 = "12.8"
     v12_6 = "12.6"
     v12_4 = "12.4"
     v12_1 = "12.1"