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

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

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