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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-cli
-Version: 1.7.2
+Version: 1.7.3
 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

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/comfy_cli/command/custom_nodes/command.py

@@ -18,6 +18,7 @@ from comfy_cli.command.custom_nodes.cm_cli_util import execute_cm_cli, find_cm_c
 from comfy_cli.config_manager import ConfigManager
 from comfy_cli.constants import NODE_ZIP_FILENAME
 from comfy_cli.file_utils import (
+    DownloadException,
     download_file,
     extract_package_as_zip,
     upload_file_to_signed_url,
@@ -170,13 +171,11 @@ def execute_install_script(repo_path):
     if os.path.exists(requirements_path):
         print("Install: pip packages")
         python = resolve_workspace_python(workspace_manager.workspace_path)
-        with open(requirements_path, encoding="utf-8") as requirements_file:
-            for line in requirements_file:
-                package_name = line.strip()
-                if package_name and not package_name.startswith("#"):
-                    install_cmd = [python, "-m", "pip", "install", package_name]
-                    if package_name.strip() != "":
-                        try_install_script(repo_path, install_cmd)
+        # Absolute path so pip doesn't re-resolve it against cwd=repo_path
+        # in try_install_script, which would double the path if repo_path
+        # is relative.
+        install_cmd = [python, "-m", "pip", "install", "-r", os.path.abspath(requirements_path)]
+        try_install_script(repo_path, install_cmd)
 
     if os.path.exists(install_script_path):
         print("Install: install script")
@@ -1168,7 +1167,12 @@ def registry_install(
 
     local_filename = node_specific_path / f"{node_id}-{node_version.version}.zip"
     logging.debug(f"Start downloading the node {node_id} version {node_version.version} to {local_filename}")
-    download_file(node_version.download_url, local_filename)
+    try:
+        download_file(node_version.download_url, local_filename)
+    except DownloadException as e:
+        logging.error(f"Failed to download node {node_id} version {node_version.version}: {e}")
+        ui.display_error_message(f"Failed to download the custom node {node_id}: {e}")
+        raise typer.Exit(code=1) from None
 
     # Extract the downloaded archive to the custom_node directory on the workspace.
     logging.debug(f"Start extracting the node {node_id} version {node_version.version} to {custom_nodes_path}")

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

@@ -8,6 +8,7 @@ from urllib.parse import parse_qs, unquote, urlparse
 import requests
 import typer
 from rich import print
+from rich.markup import escape
 
 from comfy_cli import constants, tracking, ui
 from comfy_cli.config_manager import ConfigManager
@@ -20,6 +21,8 @@ app = typer.Typer()
 workspace_manager = WorkspaceManager()
 config_manager = ConfigManager()
 
+_CIVITAI_SUBDOMAIN_SUFFIXES = tuple(f".{h}" for h in constants.CIVITAI_ALLOWED_HOSTS)
+
 
 model_path_map = {
     "lora": "loras",
@@ -98,7 +101,7 @@ def check_civitai_url(url: str) -> tuple[bool, bool, int | None, int | None]:
     try:
         parsed = urlparse(url)
         host = (parsed.hostname or "").lower()
-        if host != "civitai.com" and not host.endswith(".civitai.com"):
+        if host not in constants.CIVITAI_ALLOWED_HOSTS and not host.endswith(_CIVITAI_SUBDOMAIN_SUFFIXES):
             return False, False, None, None
         p_parts = [p for p in parsed.path.split("/") if p]
         query = parse_qs(parsed.query)
@@ -354,7 +357,13 @@ 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, downloader=resolved_downloader)
+        try:
+            download_file(url, local_filepath, headers, downloader=resolved_downloader)
+        except DownloadException as e:
+            # escape() so a dynamic error message containing "[/]" or similar
+            # rich-markup syntax doesn't trigger MarkupError or get mis-rendered.
+            print(f"[bold red]{escape(str(e))}[/bold red]")
+            raise typer.Exit(code=1) from None
 
     elapsed = time.monotonic() - start_time
     print(f"Done in {_format_elapsed(elapsed)}")

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

@@ -47,6 +47,7 @@ CONFIG_KEY_UV_COMPILE_DEFAULT = "uv_compile_default"
 
 CIVITAI_API_TOKEN_KEY = "civitai_api_token"
 CIVITAI_API_TOKEN_ENV_KEY = "CIVITAI_API_TOKEN"
+CIVITAI_ALLOWED_HOSTS: tuple[str, ...] = ("civitai.com", "civitai.red")
 HF_API_TOKEN_KEY = "hf_api_token"
 HF_API_TOKEN_ENV_KEY = "HF_API_TOKEN"
 

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/comfy_cli/file_utils.py

@@ -4,6 +4,7 @@ import pathlib
 import subprocess
 import time
 import zipfile
+from http import HTTPStatus
 
 import httpx
 import requests
@@ -82,6 +83,7 @@ def _poll_aria2_download(download) -> None:
         DownloadColumn(),
         TransferSpeedColumn(),
         TimeRemainingColumn(),
+        transient=True,
     ) as progress:
         task = progress.add_task("Downloading...", total=None)
 
@@ -172,6 +174,22 @@ _TRANSIENT_EXCEPTIONS = (
     httpx.ProtocolError,
     httpx.ProxyError,
 )
+# HTTP statuses that typically indicate a transient server-side or rate-limit
+# problem worth retrying with backoff. Auth/not-found/redirect statuses stay
+# out of this set so they fail fast.
+_RETRIABLE_STATUSES = frozenset({408, 429, 500, 502, 503, 504})
+
+
+class _TransientHTTPStatusError(Exception):
+    """Retriable HTTP status returned by the server (e.g. 500/503/429)."""
+
+    def __init__(self, status_code: int, reason: str):
+        self.status_code = status_code
+        self.reason = reason
+        super().__init__(f"HTTP {status_code}: {reason}")
+
+
+_RETRIABLE_EXCEPTIONS = _TRANSIENT_EXCEPTIONS + (_TransientHTTPStatusError,)
 
 
 def _cleanup_partial(filepath: pathlib.Path) -> None:
@@ -184,6 +202,14 @@ def _cleanup_partial(filepath: pathlib.Path) -> None:
 
 def _friendly_network_error(exc: Exception) -> str:
     """Return a user-friendly description of a network error."""
+    if isinstance(exc, _TransientHTTPStatusError):
+        try:
+            phrase = HTTPStatus(exc.status_code).phrase
+            return f"the server returned HTTP {exc.status_code} {phrase}"
+        except ValueError:
+            return f"the server returned HTTP {exc.status_code}"
+    if isinstance(exc, httpx.InvalidURL):
+        return f"invalid URL ({exc})"
     if isinstance(exc, httpx.ReadTimeout):
         return "the server stopped sending data (read timeout)"
     if isinstance(exc, httpx.ConnectTimeout):
@@ -221,6 +247,8 @@ def _download_file_httpx(
             except _TRANSIENT_EXCEPTIONS:
                 error_body = ""
             status_reason = guess_status_code_reason(response.status_code, error_body)
+            if response.status_code in _RETRIABLE_STATUSES:
+                raise _TransientHTTPStatusError(response.status_code, status_reason)
             raise DownloadException(f"Failed to download file.\n{status_reason}")
 
         content_length = response.headers.get("Content-Length")
@@ -261,7 +289,7 @@ def download_file(url: str, local_filepath: pathlib.Path, headers: dict | None =
         try:
             _download_file_httpx(url, local_filepath, headers, state=state)
             return
-        except _TRANSIENT_EXCEPTIONS as exc:
+        except _RETRIABLE_EXCEPTIONS as exc:
             last_exc = exc
             # Only clean up if _download_file_httpx actually opened the destination —
             # otherwise we'd delete an unrelated pre-existing file at the same path.
@@ -272,6 +300,15 @@ def download_file(url: str, local_filepath: pathlib.Path, headers: dict | None =
                 print(f"Download error (attempt {attempt + 1}/{_DOWNLOAD_MAX_RETRIES}): {_friendly_network_error(exc)}")
                 print(f"Retrying in {wait}s...")
                 time.sleep(wait)
+        except (httpx.HTTPError, httpx.InvalidURL) as exc:
+            # Non-retriable httpx errors (e.g. UnsupportedProtocol, TooManyRedirects,
+            # DecodingError, InvalidURL). Fail fast and convert to DownloadException
+            # so callers only need to handle one error type.
+            # InvalidURL inherits directly from Exception (not HTTPError), hence the
+            # explicit inclusion.
+            if state["file_opened"]:
+                _cleanup_partial(local_filepath)
+            raise DownloadException(f"Download failed: {_friendly_network_error(exc)}") from exc
         except KeyboardInterrupt:
             # Only prompt/cleanup if we actually opened the destination this attempt.
             # If the interrupt arrived during connection setup, there is no partial

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/comfy_cli/registry/config_parser.py

@@ -17,6 +17,11 @@ from comfy_cli.registry.types import (
     URLs,
 )
 
+# Mirrors pip's requirements-file comment rule: `#` only starts a comment when
+# preceded by whitespace, so VCS URL fragments (`#subdirectory=`, `#egg=`) and
+# direct-URL hashes (`#sha256=`) survive.
+_inline_comment_re: re.Pattern[str] = re.compile(r"(^|\s+)#.*$")
+
 
 def create_comfynode_config():
     # Create the initial structure of the TOML document
@@ -249,7 +254,20 @@ def initialize_project_config():
     # Handle dependencies
     if os.path.exists("requirements.txt"):
         with open("requirements.txt") as req_file:
-            dependencies = [line.strip() for line in req_file if line.strip()]
+            dependencies: list[str] = []
+            for raw in req_file:
+                # Strip inline/full-line comments, then skip pip-requirements-file
+                # options (-r, -e, -c, --index-url, ...) which are not valid
+                # PEP 508 deps and would break downstream build tooling.
+                line = _inline_comment_re.sub("", raw).strip()
+                if not line:
+                    continue
+                if line.startswith("-"):
+                    print(
+                        f"Warning: skipping pip-only option from requirements.txt (not valid as PEP 508 dep): {line!r}"
+                    )
+                    continue
+                dependencies.append(line)
         project["dependencies"] = dependencies
     else:
         print("Warning: 'requirements.txt' not found. No dependencies will be added.")

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/comfy_cli/tracking.py

@@ -45,8 +45,7 @@ def track_event(event_name: str, properties: any = None):
     if properties is None:
         properties = {}
     logging.debug(f"tracking event called with event_name: {event_name} and properties: {properties}")
-    # enable_tracking = config_manager.get_bool(constants.CONFIG_KEY_ENABLE_TRACKING)
-    enable_tracking = False
+    enable_tracking = config_manager.get_bool(constants.CONFIG_KEY_ENABLE_TRACKING)
     if not enable_tracking:
         return
 
@@ -98,6 +97,7 @@ def init_tracking(enable_tracking: bool):
     """
     Initialize the tracking system by setting the user identifier and tracking enabled status.
     """
+    global user_id
     logging.debug(f"Initializing tracking with enable_tracking: {enable_tracking}")
     config_manager.set(constants.CONFIG_KEY_ENABLE_TRACKING, str(enable_tracking))
     if not enable_tracking:
@@ -109,6 +109,7 @@ def init_tracking(enable_tracking: bool):
         curr_user_id = str(uuid.uuid4())
         config_manager.set(constants.CONFIG_KEY_USER_ID, curr_user_id)
         logging.debug(f'Setting user identifier for tracking user_id: {curr_user_id}."')
+    user_id = curr_user_id
 
     # Note: only called once when the user interacts with the CLI for the
     #  first time iff the permission is granted.

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/comfy_cli/ui.py

@@ -28,7 +28,7 @@ def show_progress(iterable, total, description="Downloading..."):
     Yields:
         bytes: Chunks of data as they are processed.
     """
-    with Progress() as progress:
+    with Progress(transient=True) as progress:
         task = progress.add_task(description, total=total)
         for chunk in iterable:
             yield chunk
@@ -181,4 +181,6 @@ def display_error_message(message: str) -> None:
     Args:
         message (str): The error message to display.
     """
-    console.print(f"[red]{message}[/]")
+    # markup=False so a dynamic message containing e.g. "[/]" doesn't raise
+    # MarkupError or silently strip bracketed substrings.
+    console.print(message, style="red", markup=False)

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/comfy_cli/uv.py

@@ -37,6 +37,11 @@ def _check_call(cmd: list[str], cwd: PathLike | None = None):
 
 _req_name_re: re.Pattern[str] = re.compile(r"require\s([\w-]+)")
 
+# Mirrors pip's requirements-file comment rule (pip._internal.req.req_file.COMMENT_RE):
+# `#` only starts a comment when preceded by whitespace (or starts the line), so
+# VCS URL fragments like `#subdirectory=pkg` and `#egg=foo` survive.
+_inline_comment_re: re.Pattern[str] = re.compile(r"(^|\s+)#.*$")
+
 
 def _req_re_closure(name: str) -> re.Pattern[str]:
     return re.compile(rf"({name}\S+)")
@@ -64,8 +69,8 @@ def parse_req_file(rf: PathLike, skips: list[str] | None = None):
     opts: list[str] = []
     with open(rf) as f:
         for line in f:
-            line = line.strip()
-            if not line or line.startswith("#"):
+            line = _inline_comment_re.sub("", line).strip()
+            if not line:
                 continue
             elif "==" in line and line.split("==")[0] in skips:
                 continue

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/comfy_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-cli
-Version: 1.7.2
+Version: 1.7.3
 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

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools>=61" ]
 
 [project]
 name = "comfy-cli"
-version = "v1.7.2"                                            # Will be filled in by the CI/CD pipeline. Check publish_package.py.
+version = "v1.7.3"                                            # Will be filled in by the CI/CD pipeline. Check publish_package.py.
 description = "A CLI tool for installing and using ComfyUI."
 readme = "README.md"
 keywords = [ "comfyui", "stable diffusion" ]

{comfy_cli-1.7.2 → comfy_cli-1.7.3}/tests/test_file_utils_network.py

@@ -10,6 +10,7 @@ from comfy_cli.file_utils import (
     DownloadException,
     _cleanup_partial,
     _friendly_network_error,
+    _TransientHTTPStatusError,
     check_unauthorized,
     download_file,
     extract_package_as_zip,
@@ -192,6 +193,16 @@ def _make_failing_iter(data=b"partial", exc=None):
     return factory
 
 
+def _make_status_response(status_code, body=b""):
+    """Create a mock httpx response for a non-200 status."""
+    mock = Mock()
+    mock.status_code = status_code
+    mock.read.return_value = body
+    mock.__enter__ = Mock(return_value=mock)
+    mock.__exit__ = Mock(return_value=None)
+    return mock
+
+
 class TestCleanupPartial:
     def test_removes_existing_file(self, tmp_path):
         f = tmp_path / "partial.bin"
@@ -236,6 +247,28 @@ class TestFriendlyNetworkError:
         msg = _friendly_network_error(RuntimeError("boom"))
         assert msg == "boom"
 
+    def test_transient_http_status_known_code_includes_phrase(self):
+        # HTTP 503 -> "Service Unavailable" (from stdlib http.HTTPStatus).
+        msg = _friendly_network_error(_TransientHTTPStatusError(503, "some reason from body"))
+        assert "HTTP 503" in msg
+        assert "Service Unavailable" in msg
+
+    def test_transient_http_status_500_includes_phrase(self):
+        msg = _friendly_network_error(_TransientHTTPStatusError(500, ""))
+        assert "HTTP 500" in msg
+        assert "Internal Server Error" in msg
+
+    def test_transient_http_status_unknown_code_falls_back(self):
+        # 599 is not a standard HTTPStatus; fall back to just the numeric code.
+        msg = _friendly_network_error(_TransientHTTPStatusError(599, "weird"))
+        assert "HTTP 599" in msg
+        # No crash, no stdlib phrase embedded (since there isn't one).
+
+    def test_invalid_url(self):
+        msg = _friendly_network_error(httpx.InvalidURL("Request URL is missing a scheme"))
+        assert "invalid URL" in msg
+        assert "missing a scheme" in msg
+
 
 class TestDownloadTimeout:
     @patch("httpx.stream")
@@ -528,3 +561,302 @@ class TestDownloadPartialCleanup:
         mock_prompt.assert_called_once()
         assert dest.exists()
         assert dest.read_bytes() == b"partial data"
+
+
+class TestDownloadHTTPStatusRetry:
+    """Retry behavior for transient HTTP status codes (5xx, 429, 408)."""
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_500_retried_and_succeeds(self, mock_stream, mock_sleep, tmp_path):
+        """Download retries on HTTP 500 and succeeds on the next attempt."""
+        mock_stream.side_effect = [
+            _make_status_response(500),
+            _make_ok_response(content=b"ok"),
+        ]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+
+        assert dest.read_bytes() == b"ok"
+        assert mock_stream.call_count == 2
+        mock_sleep.assert_called_once_with(2)
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_502_retried(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = [
+            _make_status_response(502),
+            _make_ok_response(content=b"ok"),
+        ]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+        assert mock_stream.call_count == 2
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_503_retried(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = [
+            _make_status_response(503),
+            _make_ok_response(content=b"ok"),
+        ]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+        assert mock_stream.call_count == 2
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_504_retried(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = [
+            _make_status_response(504),
+            _make_ok_response(content=b"ok"),
+        ]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+        assert mock_stream.call_count == 2
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_429_retried(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = [
+            _make_status_response(429),
+            _make_ok_response(content=b"ok"),
+        ]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+        assert mock_stream.call_count == 2
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_408_retried(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = [
+            _make_status_response(408),
+            _make_ok_response(content=b"ok"),
+        ]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+        assert mock_stream.call_count == 2
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_all_retries_exhausted_on_500(self, mock_stream, mock_sleep, tmp_path):
+        """After 3 failed attempts on 500, a DownloadException is raised with a friendly message."""
+        mock_stream.side_effect = [
+            _make_status_response(500),
+            _make_status_response(500),
+            _make_status_response(500),
+        ]
+
+        dest = tmp_path / "model.bin"
+        with pytest.raises(DownloadException, match="Download failed after 3 attempts") as exc_info:
+            download_file("http://example.com/model.bin", dest)
+
+        assert "HTTP 500" in str(exc_info.value)
+        # The stdlib HTTPStatus phrase is surfaced so the user knows what 500 means.
+        assert "Internal Server Error" in str(exc_info.value)
+        assert mock_stream.call_count == 3
+        # The last transient HTTP error must be chained as __cause__ for debuggability.
+        assert isinstance(exc_info.value.__cause__, _TransientHTTPStatusError)
+        assert exc_info.value.__cause__.status_code == 500
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_retry_body_read_timeout_still_retries(self, mock_stream, mock_sleep, tmp_path):
+        """If reading the 500 response body itself times out, we still retry the request."""
+        fail_resp = Mock()
+        fail_resp.status_code = 500
+        fail_resp.read.side_effect = httpx.ReadTimeout("body read timed out")
+        fail_resp.__enter__ = Mock(return_value=fail_resp)
+        fail_resp.__exit__ = Mock(return_value=None)
+
+        mock_stream.side_effect = [fail_resp, _make_ok_response(content=b"ok")]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+
+        assert dest.read_bytes() == b"ok"
+        assert mock_stream.call_count == 2
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_mixed_transient_errors_eventually_succeed(self, mock_stream, mock_sleep, tmp_path):
+        """Retries work across a mix of network-level and HTTP-status errors."""
+        mock_stream.side_effect = [
+            _make_status_response(503),
+            httpx.ReadTimeout("timeout"),
+            _make_ok_response(content=b"finally"),
+        ]
+
+        dest = tmp_path / "model.bin"
+        download_file("http://example.com/model.bin", dest)
+
+        assert dest.read_bytes() == b"finally"
+        assert mock_stream.call_count == 3
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_404_not_retried(self, mock_stream, mock_sleep, tmp_path):
+        """404 fails fast without retry."""
+        mock_stream.return_value = _make_status_response(404)
+
+        with pytest.raises(DownloadException, match="Failed to download file"):
+            download_file("http://example.com/model.bin", tmp_path / "model.bin")
+
+        assert mock_stream.call_count == 1
+        mock_sleep.assert_not_called()
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_401_not_retried(self, mock_stream, mock_sleep, tmp_path):
+        """401 fails fast without retry."""
+        mock_stream.return_value = _make_status_response(401)
+
+        with pytest.raises(DownloadException, match="Failed to download file"):
+            download_file("http://example.com/model.bin", tmp_path / "model.bin")
+
+        assert mock_stream.call_count == 1
+        mock_sleep.assert_not_called()
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_403_not_retried(self, mock_stream, mock_sleep, tmp_path):
+        """403 fails fast without retry."""
+        mock_stream.return_value = _make_status_response(403)
+
+        with pytest.raises(DownloadException, match="Failed to download file"):
+            download_file("http://example.com/model.bin", tmp_path / "model.bin")
+
+        assert mock_stream.call_count == 1
+        mock_sleep.assert_not_called()
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_preexisting_file_preserved_on_http_status_retry_exhaust(self, mock_stream, mock_sleep, tmp_path):
+        """A pre-existing file at the destination is NOT deleted when all retries fail on HTTP 500.
+
+        The retriable HTTP status is raised before _download_file_httpx opens the output file.
+        """
+        mock_stream.side_effect = [
+            _make_status_response(500),
+            _make_status_response(500),
+            _make_status_response(500),
+        ]
+
+        dest = tmp_path / "model.bin"
+        dest.write_bytes(b"IMPORTANT pre-existing data")
+
+        with pytest.raises(DownloadException, match="Download failed after 3 attempts"):
+            download_file("http://example.com/model.bin", dest)
+
+        assert dest.exists()
+        assert dest.read_bytes() == b"IMPORTANT pre-existing data"
+
+
+class TestDownloadNonRetriableHTTPError:
+    """Non-retriable httpx errors (UnsupportedProtocol, TooManyRedirects, etc.) are wrapped
+    as DownloadException so callers only need to handle one error type and users don't
+    see a raw Python traceback."""
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_unsupported_protocol_wrapped(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = httpx.UnsupportedProtocol("Request URL has an unsupported protocol 'ftp://'")
+
+        with pytest.raises(DownloadException, match="Download failed") as exc_info:
+            download_file("ftp://example.com/model.bin", tmp_path / "model.bin")
+
+        assert isinstance(exc_info.value.__cause__, httpx.UnsupportedProtocol)
+        assert mock_stream.call_count == 1
+        mock_sleep.assert_not_called()
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_too_many_redirects_wrapped(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = httpx.TooManyRedirects("Exceeded maximum allowed redirects")
+
+        with pytest.raises(DownloadException, match="Download failed") as exc_info:
+            download_file("http://example.com/model.bin", tmp_path / "model.bin")
+
+        assert isinstance(exc_info.value.__cause__, httpx.TooManyRedirects)
+        assert mock_stream.call_count == 1
+        mock_sleep.assert_not_called()
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_decoding_error_wrapped(self, mock_stream, mock_sleep, tmp_path):
+        mock_stream.side_effect = httpx.DecodingError("Invalid compressed data")
+
+        with pytest.raises(DownloadException, match="Download failed") as exc_info:
+            download_file("http://example.com/model.bin", tmp_path / "model.bin")
+
+        assert isinstance(exc_info.value.__cause__, httpx.DecodingError)
+        assert mock_stream.call_count == 1
+        mock_sleep.assert_not_called()
+
+    @patch("comfy_cli.file_utils.time.sleep")
+    @patch("httpx.stream")
+    def test_invalid_url_wrapped(self, mock_stream, mock_sleep, tmp_path):
+        """httpx.InvalidURL does NOT subclass httpx.HTTPError — it must still be wrapped
+        as DownloadException so a malformed URL doesn't leak as a Typer traceback."""
+        mock_stream.side_effect = httpx.InvalidURL("Request URL is missing a scheme")
+
+        with pytest.raises(DownloadException, match="Download failed") as exc_info:
+            download_file("no-scheme-url", tmp_path / "model.bin")
+
+        assert isinstance(exc_info.value.__cause__, httpx.InvalidURL)
+        assert "invalid URL" in str(exc_info.value)
+        assert mock_stream.call_count == 1
+        mock_sleep.assert_not_called()
+
+    @patch("httpx.stream")
+    def test_invalid_url_preserves_preexisting_file(self, mock_stream, tmp_path):
+        """InvalidURL is raised before the output file is opened — any pre-existing
+        file at the destination path must be left intact."""
+        mock_stream.side_effect = httpx.InvalidURL("bad")
+
+        dest = tmp_path / "model.bin"
+        dest.write_bytes(b"IMPORTANT pre-existing data")
+
+        with pytest.raises(DownloadException):
+            download_file("not-a-url", dest)
+
+        assert dest.exists()
+        assert dest.read_bytes() == b"IMPORTANT pre-existing data"
+
+    @patch("httpx.stream")
+    def test_preexisting_file_preserved_on_non_retriable_error(self, mock_stream, tmp_path):
+        """A non-retriable httpx error before the output file is opened must not delete
+        an unrelated pre-existing file at the destination path."""
+        mock_stream.side_effect = httpx.UnsupportedProtocol("nope")
+
+        dest = tmp_path / "model.bin"
+        dest.write_bytes(b"IMPORTANT pre-existing data")
+
+        with pytest.raises(DownloadException):
+            download_file("ftp://example.com/model.bin", dest)
+
+        assert dest.exists()
+        assert dest.read_bytes() == b"IMPORTANT pre-existing data"
+
+    @patch("httpx.stream")
+    def test_partial_file_cleaned_up_on_mid_stream_non_retriable(self, mock_stream, tmp_path):
+        """If a non-retriable error is raised AFTER the output file is opened (mid-stream),
+        the partial file is cleaned up."""
+        resp = Mock()
+        resp.status_code = 200
+        resp.headers = {"Content-Length": "100"}
+        resp.iter_bytes = Mock(side_effect=_make_failing_iter(b"partial", httpx.DecodingError("bad")))
+        resp.__enter__ = Mock(return_value=resp)
+        resp.__exit__ = Mock(return_value=None)
+        mock_stream.return_value = resp
+
+        dest = tmp_path / "model.bin"
+        with pytest.raises(DownloadException):
+            download_file("http://example.com/model.bin", dest)
+
+        assert not dest.exists()