fix(install): make API fallback query the cloned repo, not always upstream

The fallback path inside checkout_stable_comfyui hardcoded
get_latest_release("comfyanonymous", "ComfyUI") regardless of which repo
was actually cloned. For `comfy install --url <fork> --version latest`,
that picks a tag the fork may not have, then checkout fails on it.

Plumb the install URL down to checkout_stable_comfyui and parse it into
(owner, repo) before the API call. Non-GitHub URLs (local paths, GitLab,
self-hosted) and missing URLs fall back to comfyanonymous/ComfyUI to
preserve the prior behavior on edge cases.

The local-resolver path is unchanged — it already reads tags from the
cloned repo regardless of URL, which is the right thing.

Signed-off-by: Alexander Piskun <bigcat88@icloud.com>

Author: bigcat88

comfy_cli/command/install.py

@@ -1,5 +1,6 @@
 import os
 import platform
+import re
 import subprocess
 import sys
 from typing import TypedDict
@@ -189,7 +190,7 @@ def execute(
 
     if version != "nightly":
         try:
-            checkout_stable_comfyui(version=version, repo_dir=repo_dir)
+            checkout_stable_comfyui(version=version, repo_dir=repo_dir, url=url)
         except GitHubRateLimitError as e:
             rprint(f"[bold red]Error checking out ComfyUI version: {e}[/bold red]")
             sys.exit(1)
@@ -498,14 +499,47 @@ def _resolve_latest_tag_from_local(repo_dir: str) -> tuple[str | None, bool]:
     return (best[1] if best else None), fetch_ok
 
 
-def checkout_stable_comfyui(version: str, repo_dir: str):
+_GITHUB_REPO_RE = re.compile(
+    # `github.com[:/]<owner>/<repo>` with optional `.git` and optional setuptools-style
+    # `@branch` suffix (matching what ``clone_comfyui`` accepts via ``rsplit("@", 1)``).
+    # Branch names may contain slashes (`release/1.0`), so the `@<branch>` group is greedy
+    # to end-of-string. The repo segment forbids `@` and `/` to avoid eating those parts.
+    r"github\.com[/:]([^/\s]+)/([^/@\s]+?)(?:\.git)?(?:@.+)?/?$",
+)
+
+
+def _parse_github_owner_repo(url: str | None) -> tuple[str, str] | None:
+    """Parse a GitHub repo URL into ``(owner, repo)``.
+
+    Handles the URL forms ``clone_comfyui`` accepts:
+    - ``https://github.com/owner/repo``
+    - ``https://github.com/owner/repo.git``
+    - ``https://github.com/owner/repo@branch`` (setuptools-style branch suffix)
+    - ``git@github.com:owner/repo`` (SSH form)
+
+    Returns ``None`` for empty input, local paths, or non-GitHub URLs (GitLab,
+    self-hosted, etc.) — the caller decides what to do with that.
+    """
+    if not url:
+        return None
+    match = _GITHUB_REPO_RE.search(url)
+    return (match.group(1), match.group(2)) if match else None
+
+
+def checkout_stable_comfyui(version: str, repo_dir: str, url: str | None = None):
     """
     Supports installing stable releases of Comfy (semantic versioning) or the 'latest' version.
 
     For ``version="latest"`` we resolve the highest stable semver tag from the
     local clone first to avoid burning the unauthenticated GitHub API budget
     (60 req/hr per IP). The ``releases/latest`` API is only consulted when local
     resolution turns up nothing.
+
+    The optional ``url`` is the install URL forwarded from ``execute``; it lets
+    the API fallback query the same repo we cloned from (forks included)
+    instead of always asking upstream. Non-GitHub URLs and missing URLs
+    fall back to ``comfyanonymous/ComfyUI`` so the prior behavior is preserved
+    for users who pass a local path or a non-GitHub remote.
     """
     rprint(f"Looking for ComfyUI version '{version}'...")
     if version == "latest":
@@ -518,7 +552,8 @@ def checkout_stable_comfyui(version: str, repo_dir: str):
                 )
             else:
                 rprint("[yellow]No stable release tags found locally; querying GitHub API.[/yellow]")
-            selected_release = get_latest_release("comfyanonymous", "ComfyUI")
+            owner, repo = _parse_github_owner_repo(url) or ("comfyanonymous", "ComfyUI")
+            selected_release = get_latest_release(owner, repo)
             if selected_release is None:
                 rprint(f"Error: No release found for version '{version}'.")
                 sys.exit(1)

tests/comfy_cli/command/github/test_pr.py

@@ -11,6 +11,7 @@
 from comfy_cli.command.install import (
     GitHubRateLimitError,
     PRInfo,
+    _parse_github_owner_repo,
     _resolve_latest_tag_from_local,
     checkout_stable_comfyui,
     fetch_pr_info,
@@ -626,6 +627,57 @@ def test_tag_with_v_prefix_normalized(self, tmp_path):
         assert tag == "0.20.1"
 
 
+class TestParseGithubOwnerRepo:
+    """Cover the URL parser used by the API fallback to query the same repo
+    we cloned from (forks included), instead of always asking upstream."""
+
+    @pytest.mark.parametrize(
+        "url,expected",
+        [
+            # The default URL the install command uses
+            ("https://github.com/comfyanonymous/ComfyUI", ("comfyanonymous", "ComfyUI")),
+            # With .git suffix
+            ("https://github.com/comfyanonymous/ComfyUI.git", ("comfyanonymous", "ComfyUI")),
+            # With trailing slash
+            ("https://github.com/comfyanonymous/ComfyUI/", ("comfyanonymous", "ComfyUI")),
+            # setuptools-style @branch suffix that clone_comfyui supports
+            ("https://github.com/comfyanonymous/ComfyUI@master", ("comfyanonymous", "ComfyUI")),
+            ("https://github.com/comfyanonymous/ComfyUI.git@release/1.0", ("comfyanonymous", "ComfyUI")),
+            # Forks
+            ("https://github.com/myfork/ComfyUI", ("myfork", "ComfyUI")),
+            ("https://github.com/some-user/some-repo.git", ("some-user", "some-repo")),
+            # SSH forms
+            ("git@github.com:comfyanonymous/ComfyUI", ("comfyanonymous", "ComfyUI")),
+            ("git@github.com:comfyanonymous/ComfyUI.git", ("comfyanonymous", "ComfyUI")),
+        ],
+    )
+    def test_parses_github_urls(self, url, expected):
+        assert _parse_github_owner_repo(url) == expected
+
+    @pytest.mark.parametrize(
+        "url",
+        [
+            None,
+            "",
+            "/local/path/to/comfyui",  # local path
+            "https://gitlab.com/foo/bar",  # not GitHub
+            "https://example.com/owner/repo",  # not GitHub
+            "https://github.com/owner/repo/pull/123",  # not a repo URL
+            "ftp://github.com/owner/repo",  # exotic scheme — still parses since regex matches `github.com/...`
+        ],
+    )
+    def test_returns_none_for_non_github_urls(self, url):
+        # The PR URL form (last case) intentionally doesn't match — `[^/@]+?` excludes `/`
+        # so `repo/pull/123` cannot be the second capture; we want this to fall through
+        # to the upstream default in the caller.
+        if url == "ftp://github.com/owner/repo":
+            # Edge-case: this DOES match because we don't anchor on the scheme.
+            # That's fine — owner/repo is what matters; the API call uses HTTPS regardless.
+            assert _parse_github_owner_repo(url) == ("owner", "repo")
+        else:
+            assert _parse_github_owner_repo(url) is None
+
+
 class TestCheckoutStableComfyUI:
     """Verify checkout_stable_comfyui prefers local tag resolution over the
     GitHub API for `--version latest` (issue #440), and falls back when local
@@ -685,6 +737,58 @@ def test_latest_falls_back_to_api_when_local_empty(self, mock_local, mock_api, m
         mock_api.assert_called_once_with("comfyanonymous", "ComfyUI")
         mock_co.assert_called_once_with("/repo", "v0.20.1")
 
+    @patch("comfy_cli.command.install.git_checkout_tag", return_value=True)
+    @patch("comfy_cli.command.install.get_latest_release")
+    @patch("comfy_cli.command.install._resolve_latest_tag_from_local", return_value=(None, True))
+    def test_latest_fallback_uses_fork_owner_repo_from_url(self, mock_local, mock_api, mock_co):
+        """Fork case: API fallback must query the FORK's releases/latest, not upstream's.
+
+        Otherwise we'd ask GitHub for `comfyanonymous/ComfyUI`'s latest tag and
+        try to check it out in a fork that may not have it.
+        """
+        mock_api.return_value = {"tag": "v0.20.1-myfork", "version": None, "download_url": "u"}
+
+        checkout_stable_comfyui("latest", "/repo", url="https://github.com/myfork/ComfyUI")
+
+        mock_api.assert_called_once_with("myfork", "ComfyUI")
+        mock_co.assert_called_once_with("/repo", "v0.20.1-myfork")
+
+    @patch("comfy_cli.command.install.git_checkout_tag", return_value=True)
+    @patch("comfy_cli.command.install.get_latest_release")
+    @patch("comfy_cli.command.install._resolve_latest_tag_from_local", return_value=(None, True))
+    def test_latest_fallback_strips_branch_suffix_from_url(self, mock_local, mock_api, mock_co):
+        """The setuptools-style `@branch` suffix in the install URL must not leak
+        into the API call. `clone_comfyui` already strips it before cloning."""
+        mock_api.return_value = {"tag": "v0.20.1", "version": None, "download_url": "u"}
+
+        checkout_stable_comfyui("latest", "/repo", url="https://github.com/myfork/ComfyUI.git@some-branch")
+
+        mock_api.assert_called_once_with("myfork", "ComfyUI")
+
+    @patch("comfy_cli.command.install.git_checkout_tag", return_value=True)
+    @patch("comfy_cli.command.install.get_latest_release")
+    @patch("comfy_cli.command.install._resolve_latest_tag_from_local", return_value=(None, True))
+    def test_latest_fallback_defaults_to_upstream_for_non_github_url(self, mock_local, mock_api, mock_co):
+        """Non-GitHub URLs (local paths, GitLab, etc.) fall back to upstream defaults
+        — preserves prior behavior for users whose URL we can't parse."""
+        mock_api.return_value = {"tag": "v0.20.1", "version": None, "download_url": "u"}
+
+        checkout_stable_comfyui("latest", "/repo", url="/local/path/to/comfyui")
+
+        mock_api.assert_called_once_with("comfyanonymous", "ComfyUI")
+
+    @patch("comfy_cli.command.install.git_checkout_tag", return_value=True)
+    @patch("comfy_cli.command.install.get_latest_release")
+    @patch("comfy_cli.command.install._resolve_latest_tag_from_local", return_value=(None, True))
+    def test_latest_fallback_defaults_to_upstream_when_url_omitted(self, mock_local, mock_api, mock_co):
+        """Backward compat: omitting the new `url` kwarg yields the prior behavior
+        (querying upstream)."""
+        mock_api.return_value = {"tag": "v0.20.1", "version": None, "download_url": "u"}
+
+        checkout_stable_comfyui("latest", "/repo")  # no url=
+
+        mock_api.assert_called_once_with("comfyanonymous", "ComfyUI")
+
     @patch("comfy_cli.command.install.git_checkout_tag", return_value=True)
     @patch("comfy_cli.command.install.get_latest_release")
     @patch("comfy_cli.command.install._resolve_latest_tag_from_local", return_value=(None, False))