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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-cli
-Version: 1.7.3
+Version: 1.8.0
 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.3 → comfy_cli-1.8.0}/comfy_cli/cmdline.py

@@ -446,7 +446,23 @@ def run(
         int | None,
         typer.Option(help="The timeout in seconds for the workflow execution."),
     ] = 30,
+    api_key: Annotated[
+        str | None,
+        typer.Option(
+            "--api-key",
+            envvar="COMFY_API_KEY",
+            help=(
+                "Comfy API key for API Nodes (Partner Nodes). "
+                "Embedded in the prompt body as extra_data.api_key_comfy_org on POST /prompt. "
+                "For scripting, prefer the COMFY_API_KEY environment variable so the secret "
+                "stays out of shell history."
+            ),
+        ),
+    ] = None,
 ):
+    if api_key:
+        api_key = api_key.strip() or None
+
     config = ConfigManager()
 
     if host:
@@ -470,7 +486,7 @@ def run(
     if not port:
         port = 8188
 
-    run_inner.execute(workflow, host, port, wait, verbose, local_paths, timeout)
+    run_inner.execute(workflow, host, port, wait, verbose, local_paths, timeout, api_key=api_key)
 
 
 def validate_comfyui(_env_checker):

{comfy_cli-1.7.3 → comfy_cli-1.8.0}/comfy_cli/command/code_search.py

@@ -2,6 +2,7 @@
 
 import json
 import re
+import sys
 from typing import Annotated
 from urllib.parse import quote
 
@@ -20,12 +21,19 @@ DEFAULT_COUNT = 20
 REQUEST_TIMEOUT = 30
 
 
+_TYPE_FILTER_RE = re.compile(r"(^|\s)type:")
+
+
 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)}$")
+    # Only default to file matches when the user hasn't specified their own
+    # type: filter — otherwise respect whatever they passed (e.g. type:commit).
+    if not _TYPE_FILTER_RE.search(query):
+        parts.append("type:file")
     parts.append(f"count:{count}")
     parts.append(query)
     return " ".join(parts)
@@ -56,20 +64,21 @@ def _format_results(search: dict) -> list[dict]:
         commit_hash = (default_branch.get("target") or {}).get("commit", {}).get("oid", "")
         ref = commit_hash or branch_name
 
+        encoded_path = quote(file_path, safe="/")
+        file_url = f"https://github.com/{clean_name}/blob/{ref}/{encoded_path}"
+
         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}"})
+        for m in line_matches:
+            line = m.get("lineNumber", 0) + 1
+            preview = m.get("preview", "").rstrip()
+            matches.append({"line": line, "preview": preview, "url": f"{file_url}#L{line}"})
 
         formatted.append(
             {
                 "repository": clean_name,
                 "file": file_path,
+                "file_url": file_url,
                 "branch": branch_name,
                 "commit": commit_hash,
                 "matches": matches,
@@ -96,19 +105,34 @@ def _print_results(results: list[dict], stats: dict, json_output: bool) -> None:
         console.print("[yellow]No results found.[/yellow]")
         return
 
+    # Use raw isatty() rather than Rich's console.is_terminal: Rich treats
+    # FORCE_COLOR=1 / TTY_COMPATIBLE=1 as terminal-capable even when stdout
+    # is redirected, but OSC 8 escapes in a piped stream defeat the whole
+    # point of this branch (hiding URLs from humans, exposing them to AI).
+    is_tty = sys.stdout.isatty()
+
     for file_result in results:
+        repo = file_result["repository"]
+        path = file_result["file"]
+        file_url = file_result["file_url"]
+
         header = Text()
-        header.append(file_result["repository"], style="bold cyan")
-        header.append(" / ", style="dim")
-        header.append(file_result["file"], style="bold")
+        if is_tty:
+            # Humans: clickable OSC 8 hyperlink, URL hidden from visible output.
+            header.append(f"{repo} / {path}", style=f"bold cyan link {file_url}")
+        else:
+            # Non-TTY (pipes, AI agents): print the raw URL once per file so
+            # agents can synthesize #L<line> anchors themselves.
+            header.append(f"{repo} / {path}\n")
+            header.append(f"  {file_url}", style="dim")
         console.print(header)
 
         for match in file_result["matches"]:
-            line_text = Text()
-            line_text.append(f"  L{match['line']:>5}", style="green")
+            line_text = Text("  ")
+            line_style = f"green link {match['url']}" if is_tty else "green"
+            line_text.append(f"L{match['line']:>5}", style=line_style)
             line_text.append(f"  {match['preview']}")
             console.print(line_text)
-            console.print(f"        [dim]{match['url']}[/dim]")
 
         console.print()
 
@@ -121,7 +145,15 @@ def _print_results(results: list[dict], stats: dict, json_output: bool) -> None:
 @app.callback(invoke_without_command=True)
 @tracking.track_command()
 def code_search(
-    query: Annotated[str, typer.Argument(help="Search query (supports Sourcegraph syntax)")],
+    query: Annotated[
+        str,
+        typer.Argument(
+            help=(
+                "Search query (supports Sourcegraph syntax). Defaults to file matches; "
+                "pass your own `type:` filter (e.g. `type:commit`) to override."
+            ),
+        ),
+    ],
     repo: Annotated[
         str | None,
         typer.Option("--repo", "-r", help="Filter by repository (e.g. ComfyUI, Comfy-Org/ComfyUI)"),

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

@@ -975,6 +975,17 @@ def validate_node_for_publishing():
     # Perform some validation logic here
     typer.echo("Validating node configuration...")
     config = extract_node_configuration()
+    if config is None:
+        raise typer.Exit(code=1)
+
+    if not config.project.version:
+        # Escape `[` chars so rich doesn't parse `[tool.comfy.version]` and
+        # `["version"]` as markup tags; `]` doesn't need escaping.
+        print(
+            "[red]Error: project version is empty. Set `project.version` in pyproject.toml, "
+            r'or configure `\[tool.comfy.version].path` if using `dynamic = \["version"]`.[/red]'
+        )
+        raise typer.Exit(code=1)
 
     # Run security checks first
     typer.echo("Running security checks...")

{comfy_cli-1.7.3 → comfy_cli-1.8.0}/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)
@@ -434,17 +435,136 @@ def clone_comfyui(url: str, repo_dir: str):
         subprocess.run(["git", "clone", url, repo_dir], check=True)
 
 
-def checkout_stable_comfyui(version: str, repo_dir: str):
+def _resolve_latest_tag_from_local(repo_dir: str) -> tuple[str | None, bool]:
+    """Pick the highest stable semver tag from the local clone.
+
+    Returns ``(tag, fetch_ok)``:
+    - ``tag``: the tag string (e.g. ``"v0.20.1"``), or ``None`` when no stable
+      semver tag is available (or the directory isn't a git repo).
+    - ``fetch_ok``: whether ``git fetch --tags`` succeeded. Callers can use this
+      to distinguish "no new releases" from "couldn't reach the remote", which
+      changes the right messaging when falling back to the API.
+
+    Pre-release tags (e.g. ``v1.2.3-rc1``) are skipped to mirror GitHub's
+    ``releases/latest`` behavior. Note that this picks the highest semver tag,
+    which may differ from the release a maintainer has manually marked as
+    "Latest" on GitHub — acceptable trade-off given the unauthenticated API's
+    60 req/hr per-IP cap; users can pin a specific version with ``--version``
+    if needed.
+
+    ``git_checkout_tag`` skips its own ``git fetch --tags`` when the resolved
+    tag is already present locally, so on the happy path we fetch exactly once
+    here. Crucially, that also lets the cached-tag offline path succeed: if
+    fetch above fails (``fetch_ok=False``) but a tag is found from disk,
+    ``git_checkout_tag`` will not retry the unreachable fetch.
+    """
+    fetch_ok = False
+    try:
+        completed = subprocess.run(
+            ["git", "-C", repo_dir, "fetch", "--tags", "--quiet"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        fetch_ok = completed.returncode == 0
+    except (subprocess.SubprocessError, FileNotFoundError, OSError):
+        # Tolerate timeout / OS-level failure; fall through with whatever's on disk.
+        pass
+
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo_dir, "tag", "--list"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=10,
+        )
+    except (subprocess.SubprocessError, FileNotFoundError, OSError):
+        return None, fetch_ok
+
+    best: tuple[semver.VersionInfo, str] | None = None
+    for line in result.stdout.splitlines():
+        tag = line.strip()
+        if not tag:
+            continue
+        try:
+            parsed = semver.VersionInfo.parse(tag.lstrip("v"))
+        except ValueError:
+            continue
+        if parsed.prerelease:
+            continue
+        if best is None or parsed > best[0]:
+            best = (parsed, tag)
+
+    return (best[1] if best else None), fetch_ok
+
+
+_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":
-        selected_release = get_latest_release("comfyanonymous", "ComfyUI")
-        if selected_release is None:
-            rprint(f"Error: No release found for version '{version}'.")
-            sys.exit(1)
-        tag = str(selected_release["tag"])
+        tag, fetch_ok = _resolve_latest_tag_from_local(repo_dir)
+        if tag is None:
+            if not fetch_ok:
+                rprint(
+                    "[yellow]Could not refresh tags from the remote (offline or auth failure); "
+                    "trying GitHub API as a last resort.[/yellow]"
+                )
+            else:
+                rprint("[yellow]No stable release tags found locally; querying GitHub API.[/yellow]")
+            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)
+            tag = str(selected_release["tag"])
+        elif not fetch_ok:
+            # Tag list comes from a cached state — flag it so the user knows
+            # they may not be on the actual newest release.
+            rprint(
+                f"[yellow]Warning: could not refresh tags from remote; "
+                f"using cached tag {tag}. Re-run with network access to get the newest release.[/yellow]"
+            )
     else:
         # For specific versions, directly construct the tag (add 'v' prefix if needed)
         tag = f"v{version}" if not version.startswith("v") else version
@@ -490,9 +610,18 @@ def get_latest_release(repo_owner: str, repo_name: str) -> GithubRelease | None:
 
         data = response.json()
 
+        # Forks may use non-semver tags (e.g. "release-2026-04"); the caller
+        # only needs the raw tag string for git checkout, so let `version`
+        # fall back to None instead of crashing.
+        tag_name = data["tag_name"]
+        try:
+            parsed_version = semver.VersionInfo.parse(tag_name.lstrip("v"))
+        except ValueError:
+            parsed_version = None
+
         return GithubRelease(
-            tag=data["tag_name"],
-            version=semver.VersionInfo.parse(data["tag_name"].lstrip("v")),
+            tag=tag_name,
+            version=parsed_version,
             download_url=data["zipball_url"],
         )
 

{comfy_cli-1.7.3 → comfy_cli-1.8.0}/comfy_cli/command/run.py

@@ -14,28 +14,67 @@ from rich.progress import BarColumn, Column, Progress, Table, TimeElapsedColumn
 from websocket import WebSocket, WebSocketException, WebSocketTimeoutException
 
 from comfy_cli.env_checker import check_comfy_server_running
+from comfy_cli.workflow_to_api import WorkflowConversionError, convert_ui_to_api
 from comfy_cli.workspace_manager import WorkspaceManager
 
 workspace_manager = WorkspaceManager()
 
 
-def load_api_workflow(file: str):
-    with open(file, encoding="utf-8") as f:
-        workflow = json.load(f)
-        # Check for litegraph properties to ensure this isnt a UI workflow file
-        if "nodes" in workflow and "links" in workflow:
-            return None
+def is_ui_workflow(workflow) -> bool:
+    return (
+        isinstance(workflow, dict)
+        and isinstance(workflow.get("nodes"), list)
+        and isinstance(workflow.get("links"), list)
+    )
 
-        # Try validating the first entry to ensure it has a node class property
-        node_id = next(iter(workflow))
-        node = workflow[node_id]
-        if "class_type" not in node:
-            return None
 
-        return workflow
+def _validate_api_workflow(workflow):
+    """Return the workflow dict if it has the shape of API format, else None."""
+    if not isinstance(workflow, dict) or not workflow:
+        return None
+    node = workflow[next(iter(workflow))]
+    if not isinstance(node, dict) or "class_type" not in node:
+        return None
+    return workflow
 
 
-def execute(workflow: str, host, port, wait=True, verbose=False, local_paths=False, timeout=30):
+def fetch_object_info(host: str, port: int, timeout: int) -> dict:
+    """GET ``/object_info`` from the running ComfyUI server.
+
+    The response describes every loaded node class's input schema and is what
+    the converter uses to map widget values to input names, fill defaults, etc.
+    """
+    url = f"http://{host}:{port}/object_info"
+    try:
+        with request.urlopen(url, timeout=timeout) as resp:
+            body = resp.read()
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace").strip()
+        pprint(f"[bold red]Failed to fetch /object_info (HTTP {e.code}): {body[:500]}[/bold red]")
+        raise typer.Exit(code=1) from e
+    except urllib.error.URLError as e:
+        pprint(f"[bold red]Failed to fetch /object_info: {e.reason}[/bold red]")
+        raise typer.Exit(code=1) from e
+    except TimeoutError as e:
+        pprint(f"[bold red]Failed to fetch /object_info: timed out after {timeout}s[/bold red]")
+        raise typer.Exit(code=1) from e
+    try:
+        return json.loads(body)
+    except json.JSONDecodeError as e:
+        pprint("[bold red]Failed to fetch /object_info: server returned invalid JSON[/bold red]")
+        raise typer.Exit(code=1) from e
+
+
+def execute(
+    workflow: str,
+    host,
+    port,
+    wait=True,
+    verbose=False,
+    local_paths=False,
+    timeout=30,
+    api_key: str | None = None,
+):
     workflow_name = os.path.abspath(os.path.expanduser(workflow))
     if not os.path.isfile(workflow):
         pprint(
@@ -44,16 +83,51 @@ def execute(workflow: str, host, port, wait=True, verbose=False, local_paths=Fal
         )
         raise typer.Exit(code=1)
 
-    workflow = load_api_workflow(workflow)
-
-    if not workflow:
-        pprint("[bold red]Specified workflow does not appear to be an API workflow json file[/bold red]")
-        raise typer.Exit(code=1)
-
     if not check_comfy_server_running(port, host):
         pprint(f"[bold red]ComfyUI not running on specified address ({host}:{port})[/bold red]")
         raise typer.Exit(code=1)
 
+    try:
+        with open(workflow_name, encoding="utf-8") as f:
+            raw_workflow = json.load(f)
+    except OSError as e:
+        pprint(f"[bold red]Unable to read workflow file: {e}[/bold red]")
+        raise typer.Exit(code=1) from e
+    except json.JSONDecodeError as e:
+        pprint(f"[bold red]Specified workflow file is not valid JSON: {e}[/bold red]")
+        raise typer.Exit(code=1) from e
+
+    if is_ui_workflow(raw_workflow):
+        pprint("[yellow]Detected UI-format workflow, converting to API format...[/yellow]")
+        object_info = fetch_object_info(host, port, timeout)
+        try:
+            workflow = convert_ui_to_api(raw_workflow, object_info)
+        except WorkflowConversionError as e:
+            pprint(f"[bold red]Workflow conversion failed: {e}[/bold red]")
+            raise typer.Exit(code=1) from e
+        except Exception as e:
+            # The converter is experimental; an unexpected crash here is a bug
+            # in our code, not user error. Show a clean message and a pointer.
+            pprint(
+                f"[bold red]Workflow conversion crashed unexpectedly: {type(e).__name__}: {e}[/bold red]\n"
+                "[yellow]The UI-to-API converter is experimental. Please report this at[/yellow]\n"
+                "[yellow]  https://github.com/Comfy-Org/comfy-cli/issues[/yellow]\n"
+                "[yellow]and attach the workflow file if possible.[/yellow]"
+            )
+            if verbose:
+                import traceback
+
+                traceback.print_exc()
+            raise typer.Exit(code=1) from e
+        if not workflow:
+            pprint("[bold red]Workflow conversion produced no executable nodes[/bold red]")
+            raise typer.Exit(code=1)
+    else:
+        workflow = _validate_api_workflow(raw_workflow)
+        if not workflow:
+            pprint("[bold red]Specified workflow does not appear to be an API workflow json file[/bold red]")
+            raise typer.Exit(code=1)
+
     progress = None
     start = time.time()
     if wait:
@@ -63,7 +137,7 @@ def execute(workflow: str, host, port, wait=True, verbose=False, local_paths=Fal
     else:
         print(f"Queuing workflow: {workflow_name}")
 
-    execution = WorkflowExecution(workflow, host, port, verbose, progress, local_paths, timeout)
+    execution = WorkflowExecution(workflow, host, port, verbose, progress, local_paths, timeout, api_key=api_key)
 
     try:
         if wait:
@@ -117,7 +191,7 @@ class ExecutionProgress(Progress):
 
 
 class WorkflowExecution:
-    def __init__(self, workflow, host, port, verbose, progress, local_paths, timeout=30):
+    def __init__(self, workflow, host, port, verbose, progress, local_paths, timeout=30, api_key: str | None = None):
         self.workflow = workflow
         self.host = host
         self.port = port
@@ -136,14 +210,20 @@ class WorkflowExecution:
         self.prompt_id = None
         self.ws = None
         self.timeout = timeout
+        self.api_key = api_key
 
     def connect(self):
         self.ws = WebSocket()
         self.ws.connect(f"ws://{self.host}:{self.port}/ws?clientId={self.client_id}")
 
     def queue(self):
-        data = {"prompt": self.workflow, "client_id": self.client_id}
-        req = request.Request(f"http://{self.host}:{self.port}/prompt", json.dumps(data).encode("utf-8"))
+        data: dict = {"prompt": self.workflow, "client_id": self.client_id}
+        if self.api_key:
+            data["extra_data"] = {"api_key_comfy_org": self.api_key}
+        req = request.Request(
+            f"http://{self.host}:{self.port}/prompt",
+            json.dumps(data).encode("utf-8"),
+        )
         try:
             resp = request.urlopen(req)
             body = json.loads(resp.read())

{comfy_cli-1.7.3 → comfy_cli-1.8.0}/comfy_cli/git_utils.py

@@ -28,9 +28,16 @@ def git_checkout_tag(repo_path: str, tag: str) -> bool:
     """
     Checkout a specific Git tag in the given repository.
 
+    Skips the network ``git fetch --tags`` when the tag already exists locally.
+    This avoids a redundant round-trip on the happy path (the caller usually
+    just cloned the repo or just ran a fetch via the resolver) and lets offline
+    installs proceed when the tag is already cached. Only when the tag is
+    absent locally do we attempt to fetch — and a failed fetch in that case is
+    a real, unrecoverable error (``check=True`` surfaces it as before).
+
     :param repo_path: Path to the Git repository
     :param tag: The tag to checkout
-    :return: The output of the git command if successful, None if an error occurred
+    :return: True if the checkout succeeds, False if any git command failed.
     """
     original_dir = os.getcwd()
     try:
@@ -38,8 +45,18 @@ def git_checkout_tag(repo_path: str, tag: str) -> bool:
 
         os.chdir(repo_path)
 
-        # Fetch the latest tags
-        subprocess.run(["git", "fetch", "--tags"], check=True, capture_output=True, text=True)
+        # Skip the network fetch when the tag is already present locally.
+        tag_present_locally = (
+            subprocess.run(
+                ["git", "rev-parse", "--verify", f"refs/tags/{tag}"],
+                capture_output=True,
+                text=True,
+                check=False,
+            ).returncode
+            == 0
+        )
+        if not tag_present_locally:
+            subprocess.run(["git", "fetch", "--tags"], check=True, capture_output=True, text=True)
 
         # Checkout the specified tag
         subprocess.run(["git", "checkout", tag], check=True, capture_output=True, text=True)