comfy-cli 1.23.0__tar.gz → 1.25.0__tar.gz

{comfy_cli-1.23.0 → comfy_cli-1.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-cli
-Version: 1.23.0
+Version: 1.25.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.23.0 → comfy_cli-1.25.0}/comfy_cli/_lazy.py

@@ -32,7 +32,7 @@ from typing import TYPE_CHECKING, Any
 
 import typer
 from typer.core import TyperGroup
-from typer.models import CommandInfo, TyperInfo
+from typer.models import CommandInfo, DefaultPlaceholder, TyperInfo
 
 if TYPE_CHECKING:
     import click
@@ -105,6 +105,60 @@ class LazyCommand:
     hidden: bool = False
 
 
+def _reject_single_callback_app(name: str, spec: LazySubcommand, sub_app: typer.Typer) -> None:
+    """Refuse a ``LazySubcommand`` mount of a Typer app that is only a callback.
+
+    A Typer app with no commands and no subgroups is one function wearing an
+    app, and ``add_typer`` turns it into a click ``Group``. A group disables
+    interspersed arguments, so the first non-option token ends option parsing
+    and everything after it is read as a nested command name. The callback's
+    own positional then swallows the query and the trailing flags become a
+    subcommand that does not exist::
+
+        $ comfy code-search KSampler --repo ComfyUI
+        Usage: comfy code-search [OPTIONS] {query} COMMAND [ARGS]...
+        Error: Missing argument 'query'.
+
+    while the same flags *before* the query parse fine — the shape a user
+    hits only in the installed CLI, since calling the module's app directly
+    never exercises the root group. ``code-search`` shipped that way and was
+    moved to :class:`LazyCommand`; this keeps the next one from repeating it.
+
+    A sub-app that supplies its own ``cls`` (e.g. a nested :class:`LazyTyperGroup`
+    with its own ``lazy_subcommands`` table) is exempt: its commands are built on
+    lookup rather than registered eagerly, so ``registered_commands`` and
+    ``registered_groups`` are empty by design, not because it is a bare callback.
+    ``cls`` can be set on the app itself (``typer.Typer(cls=...)``) or on its
+    callback (``@sub_app.callback(cls=...)``); ``typer.main.solve_typer_info_defaults``
+    reads the callback's value first, so this checks both in that order.
+    """
+    if not isinstance(sub_app, typer.Typer):
+        raise TypeError(
+            f"lazy_subcommands[{name!r}] names {spec.module}.{spec.attr}, which is "
+            f"{sub_app!r}, not a typer.Typer instance."
+        )
+    if sub_app.registered_commands or sub_app.registered_groups:
+        return
+    callback = sub_app.registered_callback
+    callback_cls = callback.cls if callback is not None else DefaultPlaceholder(None)
+    effective_cls = callback_cls if not isinstance(callback_cls, DefaultPlaceholder) else sub_app.info.cls
+    if not isinstance(effective_cls, DefaultPlaceholder):
+        return
+    if sub_app.registered_callback is None:
+        raise TypeError(
+            f"lazy_subcommands[{name!r}] mounts {spec.module}.{spec.attr} as a command group, but "
+            f"that Typer app registers no commands, no subgroups, and no callback — there is nothing "
+            f"to mount. Check the module actually registers the commands you expect."
+        )
+    raise TypeError(
+        f"lazy_subcommands[{name!r}] mounts {spec.module}.{spec.attr} as a command group, but that "
+        f"Typer app registers no commands and no subgroups — it is a single callback. Mounting it as "
+        f"a group makes click demand a nested COMMAND, so options placed after the positional "
+        f'argument are rejected. Declare it as LazyCommand({spec.module!r}, attr="<function>") '
+        f"instead, naming the callback function rather than the app."
+    )
+
+
 class LazyTyperGroup(TyperGroup):
     """Root group with subcommands declared in ``lazy_subcommands`` and built
     on first lookup. Set the table on a subclass::
@@ -174,6 +228,7 @@ class LazyTyperGroup(TyperGroup):
 
     def _build_group(self, name: str, spec: LazySubcommand) -> click.Command:
         sub_app = getattr(importlib.import_module(spec.module), spec.attr)
+        _reject_single_callback_app(name, spec, sub_app)
         # Same TyperInfo ``add_typer`` would have appended: only the keywords
         # that were given, so the sub-app's own settings fill the rest.
         kwargs: dict[str, Any] = {"name": name}

{comfy_cli-1.23.0 → comfy_cli-1.25.0}/comfy_cli/builder_api.py

@@ -116,7 +116,14 @@ class BuilderClient:
     ``X-API-Key``, via the shared authed HTTP path (HTTPS-enforced, no credential
     replay on redirect, response-size capped)."""
 
-    def __init__(self, base_url: str, token: str | None = None, *, api_key: Credential | None = None):
+    def __init__(
+        self,
+        base_url: str,
+        token: str | None = None,
+        *,
+        api_key: Credential | None = None,
+        token_env_var: str = "COMFY_BUILDER_TOKEN",
+    ):
         # kind="cloud" is what makes the shared http layer attach the credential;
         # path_prefix carries the /v1 base so target.url("builds") is right.
         self.target = Target(
@@ -127,18 +134,27 @@ class BuilderClient:
             api_key=api_key.value if api_key is not None else None,
         )
         # Only a client built from the stored sign-in may swap its token; one
-        # handed a token (COMFY_BUILDER_TOKEN) or a key keeps it and lets a 401 surface.
+        # handed a token (COMFY_BUILDER_TOKEN, COMFY_CLOUD_AUTH_TOKEN) or a key keeps
+        # it and lets a 401 surface.
         self._refreshes_on_401 = False
         # What to replace once the builder refuses this client's credential.
         self._refused_hint = (
             credentials.refused_key_hint(api_key)
             if api_key is not None
-            else "replace COMFY_BUILDER_TOKEN with a fresh Cloud JWT"
+            else f"replace {token_env_var} with a fresh Cloud JWT"
         )
 
     @classmethod
     def from_credentials(cls, base_url: str) -> BuilderClient:
-        """Build a client from the workspace API key when one is set, else from the sign-in."""
+        """Build a client from a credential handed in by env when one is set, else from the sign-in.
+
+        ``COMFY_CLOUD_AUTH_TOKEN``, then ``COMFY_CLOUD_API_KEY``, outrank the
+        stored sign-in, which is then not refreshed; the saved set-key key comes
+        only after the sign-in.
+        """
+        token = credentials.platform_env_token()
+        if token:
+            return cls(base_url, token, token_env_var=credentials.CLOUD_BEARER_ENV_VAR)
         key = credentials.platform_api_key()
         if key is None:
             try:

{comfy_cli-1.23.0 → comfy_cli-1.25.0}/comfy_cli/cloud/command.py

@@ -182,12 +182,16 @@ def logout_cmd():
 @app.command("whoami", help="Show the current Comfy Cloud sign-in status.")
 @tracking.track_command("cloud")
 def whoami_cmd():
-    from comfy_cli.credentials import find_api_key, get_session
+    from comfy_cli.credentials import env_credential, find_api_key, get_session
 
     renderer = get_renderer()
+    # A credential handed in by env outranks the stored sign-in for every cloud
+    # call, so whoami reports that one as the identity in effect.
+    handed_in = env_credential("cloud")
     # Refresh first so we report (and persist) a live token rather than a
-    # token that quietly lapsed since the last command.
-    session = get_session(refresh=True)
+    # token that quietly lapsed since the last command — but only when the
+    # sign-in is what cloud calls will send. Otherwise it is read as stored.
+    session = get_session(refresh=handed_in is None)
     configured_base_url = get_base_url()
 
     # Ambient API key (env / store), reported even when an OAuth session
@@ -198,28 +202,47 @@ def whoami_cmd():
     if ambient_key is not None:
         api_key_source = "env" if ambient_key.source.startswith("env:") else "store"
 
-    # `signed_in` reflects *any* valid auth path — OAuth session or API key.
-    # When both are present, OAuth wins (it's the credential the client sends);
-    # the API key is only used as a fallback when no live session exists.
+    # `signed_in` reflects *any* valid auth path. Precedence matches what the
+    # client sends: a credential handed in by env (COMFY_CLOUD_AUTH_TOKEN, then
+    # COMFY_CLOUD_API_KEY), then a live OAuth session, then the stored key.
+    # `credential_source` names the one in effect ("env:<VAR>", "session",
+    # "stored:<provider>").
     has_api_key = api_key_source is not None
     has_oauth = session is not None
     expired = session.is_expired() if session else None
-    oauth_usable = has_oauth and not expired
+    # A session minted for another base URL is never sent to the configured
+    # one (the replay-guard in resolve_target), so it is not usable here.
+    stale_base_url = (session.base_url != configured_base_url) if session else False
+    oauth_usable = has_oauth and not expired and not stale_base_url
     # `signed_in` must reflect whether we can actually authenticate right now:
-    # a live (non-expired) OAuth session, or an API key. An expired,
-    # unrefreshable OAuth session is NOT signed in on its own.
-    signed_in = oauth_usable or has_api_key
+    # a handed-in credential, a live (non-expired) OAuth session, or an API
+    # key. An expired, unrefreshable OAuth session is NOT signed in on its own.
+    signed_in = handed_in is not None or oauth_usable or has_api_key
     auth_method: str | None
-    if oauth_usable:
+    credential_source: str | None
+    if handed_in is not None:
+        auth_method = handed_in.kind
+        credential_source = handed_in.source
+    elif oauth_usable:
         auth_method = "oauth"
-    elif has_api_key:
+        credential_source = "session"
+    elif ambient_key is not None:
         auth_method = "api_key"
+        credential_source = ambient_key.source
     else:
         auth_method = None
-    stale_base_url = (session.base_url != configured_base_url) if session else False
+        credential_source = None
 
     if renderer.is_pretty():
-        if has_oauth:
+        if handed_in is not None:
+            env_var = handed_in.source.removeprefix("env:")
+            rprint(f"[bold]Authenticated via {env_var}[/bold] [dim](handed in by the environment)[/dim]")
+            if has_oauth:
+                rprint(
+                    f"[dim]A stored `comfy cloud login` session ({session.base_url}) is present "
+                    f"but unused while {env_var} is set.[/dim]"
+                )
+        elif has_oauth:
             from comfy_cli.output.branding import whoami_banner
 
             renderer.console().print(
@@ -244,7 +267,8 @@ def whoami_cmd():
                         f"[dim]OAuth session is preferred; X-API-Key from {api_key_source} present but unused.[/dim]"
                     )
                 else:
-                    rprint(f"[dim]OAuth session expired — falling back to X-API-Key from {api_key_source}.[/dim]")
+                    reason = "is for another base URL" if stale_base_url else "expired"
+                    rprint(f"[dim]OAuth session {reason} — falling back to X-API-Key from {api_key_source}.[/dim]")
         else:
             from comfy_cli.output.branding import signed_out_banner
 
@@ -260,9 +284,13 @@ def whoami_cmd():
     payload: dict[str, object | None] = {
         "signed_in": signed_in,
         "auth_method": auth_method,
-        "base_url": session.base_url if session else configured_base_url,
+        # The URL the credential in effect goes to. Cloud calls always go to the
+        # configured URL (a session minted for another one is not used), so
+        # this is the configured URL; the session's own URL is in `session`.
+        "base_url": configured_base_url,
         "configured_base_url": configured_base_url,
         "api_key_source": api_key_source,
+        "credential_source": credential_source,
     }
     if session is not None:
         payload["expired"] = expired

{comfy_cli-1.23.0 → comfy_cli-1.25.0}/comfy_cli/cloud/oauth.py

@@ -45,7 +45,7 @@ import urllib.request
 import webbrowser
 from dataclasses import dataclass, field
 from http.server import BaseHTTPRequestHandler
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from urllib.error import HTTPError, URLError
 
 from comfy_cli.cloud import (
@@ -56,6 +56,11 @@ from comfy_cli.cloud import (
 )
 from comfy_cli.http import NoRedirectHandler, build_http_only_opener
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from comfy_cli.auth.store import CloudSession
+
 # ---------------------------------------------------------------------------
 # Error types — caller maps these to renderer.error(code=...) codes.
 # ---------------------------------------------------------------------------
@@ -92,6 +97,19 @@ class OAuthTimeout(OAuthError):
     code = "oauth_timeout"
 
 
+class SessionReplaced(Exception):
+    """The stored sign-in is not the one ``ensure_fresh_session(expect=...)`` was asked to refresh.
+
+    Raised before anything is refreshed, persisted or cleared, so another
+    sign-in stored while the caller waited is left exactly as it was.
+    ``session`` is the sign-in found in its place.
+    """
+
+    def __init__(self, session: CloudSession) -> None:
+        super().__init__("the stored sign-in was replaced by another")
+        self.session = session
+
+
 # ---------------------------------------------------------------------------
 # Constants
 # ---------------------------------------------------------------------------
@@ -758,7 +776,13 @@ def take_last_fatal_refresh_reason() -> str | None:
     return reason
 
 
-def ensure_fresh_session(*, leeway_s: int = 60, force: bool = False, allow_clear: bool = True):
+def ensure_fresh_session(
+    *,
+    leeway_s: int = 60,
+    force: bool = False,
+    allow_clear: bool = True,
+    expect: Callable[[CloudSession], bool] | None = None,
+):
     """Return the stored cloud session, refreshing it first when the access
     token is expired (or within ``leeway_s`` of expiring) and a refresh token
     is available.
@@ -787,6 +811,13 @@ def ensure_fresh_session(*, leeway_s: int = 60, force: bool = False, allow_clear
     session lifecycle. The refresh still returns ``None`` so the caller knows it
     could not freshen the token; it just declines to destroy the shared session.
 
+    ``expect`` is for a caller bound to one sign-in (an upload finished as the
+    account that started it). It is called with the stored session on the first
+    read and again under the lock, before any refresh, persist or clear; when it
+    returns ``False`` another sign-in replaced that one (``comfy cloud login`` in
+    another shell), so :class:`SessionReplaced` is raised and the store is left
+    untouched. Without it every stored session is refreshed, as before.
+
     Concurrency: the auth server rotates the refresh token on every refresh and
     invalidates the old one. A parallel ``comfy run`` fan-out (plus background
     ``jobs watch`` processes) would otherwise have N processes each load the
@@ -800,6 +831,8 @@ def ensure_fresh_session(*, leeway_s: int = 60, force: bool = False, allow_clear
     from comfy_cli.auth import store as auth_store
 
     session = auth_store.get_cloud_session()
+    if session is not None and expect is not None and not expect(session):
+        raise SessionReplaced(session)
     if session is None or not session.refresh_token:
         return session
     if not force and not session.is_expired(leeway_s=leeway_s):
@@ -821,6 +854,7 @@ def ensure_fresh_session(*, leeway_s: int = 60, force: bool = False, allow_clear
                 leeway_s=leeway_s,
                 force=force,
                 allow_clear=allow_clear,
+                expect=expect,
             )
     except TimeoutError:
         # A peer has held the lock longer than a refresh should take. Don't
@@ -833,7 +867,15 @@ def ensure_fresh_session(*, leeway_s: int = 60, force: bool = False, allow_clear
         return session
 
 
-def _locked_refresh(auth_store, *, observed_refresh_token: str, leeway_s: int, force: bool, allow_clear: bool = True):
+def _locked_refresh(
+    auth_store,
+    *,
+    observed_refresh_token: str,
+    leeway_s: int,
+    force: bool,
+    allow_clear: bool = True,
+    expect: Callable[[CloudSession], bool] | None = None,
+):
     """Decide → POST → persist, executed while holding the secrets lock.
 
     Re-reads the persisted session first (double-checked locking): if a peer
@@ -841,6 +883,10 @@ def _locked_refresh(auth_store, *, observed_refresh_token: str, leeway_s: int, f
     one rather than spending the now-consumed token we observed before locking.
     """
     session = auth_store.get_cloud_session()
+    # Checked under the lock: another login stored since the first read is
+    # neither refreshed nor cleared on this caller's behalf.
+    if session is not None and expect is not None and not expect(session):
+        raise SessionReplaced(session)
     if session is None or not session.refresh_token:
         return session
 

{comfy_cli-1.23.0 → comfy_cli-1.25.0}/comfy_cli/cmdline.py

@@ -2002,6 +2002,33 @@ def run(
             ),
         ),
     ] = False,
+    output_node_ids: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--output-node-ids",
+            show_default=False,
+            help=(
+                "Comma-separated ids of output nodes to run (e.g. 9,12; repeatable); only they and "
+                "the nodes they depend on execute, the rest of the graph is skipped. Ids are the "
+                "API-format graph's node ids and must be output nodes. Sent to /prompt as "
+                "partial_execution_targets. Omit to run the whole graph."
+            ),
+        ),
+    ] = None,
+    client_id: Annotated[
+        str | None,
+        typer.Option(
+            "--client-id",
+            show_default=False,
+            help=(
+                "Local-only: submit as this already-connected WebSocket clientId instead of a fresh "
+                "one. ComfyUI sends a prompt's execution events only to the socket that submitted it, "
+                "so passing a browser tab's clientId is what makes that tab show node highlights, "
+                "progress and outputs for a run it did not start. This invocation then cannot watch "
+                "the run itself, so it cannot be combined with --wait."
+            ),
+        ),
+    ] = None,
 ):
     # Snapshot kwargs before the body mutates api_key/host/port — analytics should record what user actually supplied.
     _track_props = tracking.filter_command_kwargs(dict(locals()))
@@ -2047,11 +2074,51 @@ def run(
         # `where` kwarg is None then). Rides on the execution_success/_error events.
         _track_props["target"] = "cloud" if decision.target is where_module.WhereTarget.CLOUD else "local"
 
+        if client_id is not None and not client_id.strip():
+            renderer.error(
+                code="client_id_rejected",
+                message="--client-id must not be empty",
+                hint="pass the connected browser client's id, or omit --client-id",
+                details={"reason": "empty"},
+            )
+            raise typer.Exit(code=1)
+        client_id = client_id.strip() if client_id is not None else None
+        if client_id:
+            rejection = None
+            if decision.target is where_module.WhereTarget.CLOUD:
+                rejection = ("cloud", "--client-id addresses a local ComfyUI socket and has no meaning on cloud")
+            elif wait:
+                rejection = (
+                    "wait",
+                    "--client-id hands this run's events to another client, so --wait would watch a silent socket",
+                )
+            if rejection is not None:
+                reason, message = rejection
+                renderer.error(
+                    code="client_id_rejected",
+                    message=message,
+                    hint="drop --client-id, or drop the conflicting flag",
+                    details={"reason": reason},
+                )
+                raise typer.Exit(code=1)
+
         # Default for --notify: on when a human is at the terminal, off for
         # agents (they shouldn't get surprise side-channel processes they didn't
         # ask for). The user can override either way with --notify/--no-notify.
         effective_notify = notify if notify is not None else (renderer.is_pretty() and not wait)
 
+        target_ids: list[str] | None = None
+        if output_node_ids:
+            target_ids = run_inner.parse_output_node_ids(output_node_ids)
+            if not target_ids:
+                renderer.error(
+                    code="invalid_output_node_ids",
+                    message="--output-node-ids was given but names no node ids",
+                    hint="pass comma-separated output node ids, e.g. --output-node-ids 9,12; omit it to run the whole graph",
+                    details={"unknown_node_ids": [], "non_output_node_ids": []},
+                )
+                raise typer.Exit(code=1)
+
         # --prompt/--set build an in-memory API-format graph from the bundled
         # default text2img workflow (no --workflow file). The aliases resolve
         # against OUR pinned node ids, so mixing them with a user --workflow —
@@ -2106,6 +2173,7 @@ def run(
                 workflow_id=workflow_id,
                 preloaded=preloaded,
                 allow_spend=allow_spend,
+                output_node_ids=target_ids,
             )
         else:
             # Both targets must fall off the END of this try suite: Python skips
@@ -2144,6 +2212,8 @@ def run(
                 print_prompt=print_prompt,
                 preloaded=preloaded,
                 allow_spend=allow_spend,
+                output_node_ids=target_ids,
+                client_id=client_id,
             )
     except typer.Exit as e:
         if (e.exit_code or 0) == 0:

{comfy_cli-1.23.0 → comfy_cli-1.25.0}/comfy_cli/comfy_client.py

@@ -175,7 +175,12 @@ class Client:
         if self.target.api_key:
             return False
 
-        from comfy_cli.credentials import get_session
+        from comfy_cli.credentials import env_credential, get_session
+
+        # A token handed in by env is what was refused; the stored sign-in was
+        # never used, so it is not refreshed (or rewritten) on this token's behalf.
+        if env_credential("cloud") is not None:
+            return False
 
         old_token = self.target.auth_token
         # Was there a stored OAuth session backing this token? If not (e.g. a
@@ -347,6 +352,7 @@ class Client:
         timeout: float | None = None,
         extra_data: dict | None = None,
         workflow_id: str | None = None,
+        output_node_ids: list[str] | None = None,
     ) -> SubmitResult:
         """POST {prefix}/prompt — submit a workflow for execution.
 
@@ -355,6 +361,9 @@ class Client:
         forwarded as a top-level ``workflow_id`` field so the server can associate
         the job with an existing workflow and auto-promote a draft on run. Omitted
         from the body entirely when unset.
+        ``output_node_ids`` is sent as top-level ``partial_execution_targets`` so
+        the server runs only those output nodes and what they depend on; omitted
+        from the body entirely when unset, which queues the whole graph.
         For cloud submissions, the user's OAuth token is injected as
         ``auth_token_comfy_org`` so partner-API nodes (BFL Flux Pro, Gemini
         Nano Banana, etc.) can call out to comfy.org — matching what the web
@@ -385,6 +394,8 @@ class Client:
             # workflow (auto-promotes a draft on run). Only sent when provided.
             if workflow_id:
                 request_payload["workflow_id"] = workflow_id
+            if output_node_ids:
+                request_payload["partial_execution_targets"] = list(output_node_ids)
             return request_payload
 
         resp = self._request("POST", ("prompt",), body_factory=payload, timeout=timeout)