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

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

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

{comfy_cli-1.23.0 → comfy_cli-1.24.0}/comfy_cli/command/build.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 
 import contextlib
 import hashlib
+import http.client
 import io
 import json
 import os
@@ -2487,13 +2488,14 @@ def _builder_client(renderer, builder_url: str | None):
     A caller that already holds a Cloud JWT, such as the Developer Platform agent
     service forwarding the request's token, injects it via ``COMFY_BUILDER_TOKEN``,
     and that explicit token comes first. Otherwise ``from_credentials`` uses a
-    workspace API key from ``COMFY_CLOUD_API_KEY``, which a CI job sets, then the
-    stored sign-in.
+    Cloud JWT from ``COMFY_CLOUD_AUTH_TOKEN`` or a workspace API key from
+    ``COMFY_CLOUD_API_KEY``, which a CI job sets, then the stored sign-in. Empty
+    or whitespace-only values count as unset.
     """
     from comfy_cli.builder_api import BuilderAuthError, BuilderClient
 
     base_url = builder_url or os.environ.get("COMFY_BUILDER_URL") or DEFAULT_BUILDER_URL
-    token = os.environ.get("COMFY_BUILDER_TOKEN")
+    token = (os.environ.get("COMFY_BUILDER_TOKEN") or "").strip()
     if token:
         return BuilderClient(base_url, token)
     try:
@@ -2978,6 +2980,10 @@ def show_cmd(
 
 
 _RELEASE_POLL_SECONDS = 2.0
+#: Failed polls in a row a watch rides out before it ends: transport failures and
+#: answers too damaged to read, counted together. With the backoff in
+#: ``_poll_call``, about a minute of outage.
+_POLL_TRANSPORT_MISSES = 5
 
 
 #: Sorts below every usable timestamp, so a release the builder dated badly loses
@@ -3133,9 +3139,71 @@ def _selected_release_id(renderer, client, scope: _BuildScope, release: str | No
     return _newest_release_id(renderer, client, _resolve_build_id(renderer, client, scope))
 
 
+def _poll_call(renderer, fn, usable=None):
+    """``_builder_call`` for one poll of a watch, which a single timed-out or
+    dropped request must not end: the release keeps building either way. A
+    transport failure sleeps and polls again, up to ``_POLL_TRANSPORT_MISSES`` in
+    a row; the builder's own answer (an ``HTTPError``) and every other failure
+    still end the watch on the first one, through the same envelope.
+
+    The builder client is urllib-only: a connect timeout arrives wrapped in a
+    ``URLError``, a timeout or reset while awaiting the response arrives bare, and
+    a connection closed partway through the body arrives as ``IncompleteRead``.
+    A certificate the CA store refuses also arrives as a ``URLError``, but it
+    will be refused again, so it ends the watch at once with its trust hint.
+    A fixed-length body cut short arrives as no error at all: the HTTP layer
+    returns the partial bytes, which parse as ``{}``. So an answer ``usable``
+    rejects counts as a miss in the same run, and the last one ends the watch."""
+    from comfy_cli.http import tls_verification_failed
+
+    def attempt():
+        for miss in range(1, _POLL_TRANSPORT_MISSES + 1):
+            try:
+                answer = fn()
+            except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.IncompleteRead) as e:
+                if isinstance(e, urllib.error.HTTPError) or tls_verification_failed(e):
+                    raise
+                if miss == _POLL_TRANSPORT_MISSES:
+                    if isinstance(e, urllib.error.URLError):
+                        raise
+                    # Wrapped, or a bare one would escape ``_builder_call`` as a traceback.
+                    raise urllib.error.URLError(e) from e
+                renderer.warn(f"builder unreachable ({e}); polling again ({miss}/{_POLL_TRANSPORT_MISSES - 1})")
+            else:
+                if usable is None or usable(answer):
+                    return answer
+                if miss == _POLL_TRANSPORT_MISSES:
+                    renderer.error(
+                        code="build_builder_error",
+                        message=f"the builder sent no readable answer in {miss} polls in a row.",
+                    )
+                    raise typer.Exit(code=1)
+                renderer.warn(f"builder answer unreadable; polling again ({miss}/{_POLL_TRANSPORT_MISSES - 1})")
+            time.sleep(min(_RELEASE_POLL_SECONDS * 2**miss, 30.0))
+
+    return _builder_call(renderer, attempt)
+
+
+def _readable_log(answer) -> bool:
+    """The builder always sends ``log``, empty when none was captured yet, so an
+    answer without one is a body cut short."""
+    return isinstance(answer, dict) and isinstance(answer.get("log"), str)
+
+
+def _poll_status(renderer, client, release_id: str) -> dict:
+    """One status read of a watch. An answer with no status string is unreadable
+    and polled again; a whole answer naming an unknown status is the builder's
+    word and ends the watch at the caller."""
+    return _poll_call(
+        renderer,
+        lambda: client.get_release(release_id),
+        usable=lambda release: isinstance(release, dict) and isinstance(release.get("status"), str),
+    )
+
+
 def _poll_release(renderer, client, release_id: str) -> dict:
     while True:
-        release = _builder_call(renderer, lambda: client.get_release(release_id))
+        release = _poll_status(renderer, client, release_id)
         status = release.get("status")
         if renderer.is_pretty():
             renderer.info(f"release {release_id}: {status}")
@@ -3323,21 +3391,39 @@ def release_logs(
     release_id = _selected_release_id(renderer, client, _BuildScope(ctx, path, build_id), release)
     previous_log = ""
     content: dict = {}
+    complete = False
+
+    def read_log() -> dict:
+        return client.get_release_logs(release_id, os=selected_target.os, gpu=selected_target.gpu)
+
     while True:
-        content = _builder_call(
-            renderer,
-            lambda: client.get_release_logs(release_id, os=selected_target.os, gpu=selected_target.gpu),
-        )
+        # Only a follow is a watch; a single read fails fast like every other command.
+        # A body cut short inside its Content-Length parses as `{}` rather than
+        # raising. Before any whole log is in hand the follow polls again, as for
+        # a status read; after, publishing it would drop the log already read and
+        # fail `build_release_logs.json`, so the last whole log stands until a
+        # later read replaces it.
+        if follow:
+            had_log = _readable_log(content)
+            read = _poll_call(renderer, read_log, usable=lambda answer: had_log or _readable_log(answer))
+        else:
+            read = _builder_call(renderer, read_log)
+        if _readable_log(read) or not content:
+            content = read
+        elif complete:
+            renderer.warn("the final log read came back incomplete; showing the log read before the release completed")
         log = content.get("log", "")
         if renderer.is_pretty() and isinstance(log, str) and log:
             renderer.print(log[len(previous_log) :] if log.startswith(previous_log) else log)
             previous_log = log
-        if not follow:
+        if not follow or complete:
             break
-        detail = _builder_call(renderer, lambda: client.get_release(release_id))
+        detail = _poll_status(renderer, client, release_id)
         match detail.get("status"):
             case "complete":
-                break
+                # The log above may predate completion (a retried status read
+                # widens that gap), so read it once more for the final lines.
+                complete = True
             case "queued" | "building":
                 time.sleep(_RELEASE_POLL_SECONDS)
             case status:

{comfy_cli-1.23.0 → comfy_cli-1.24.0}/comfy_cli/command/deploy.py

@@ -52,6 +52,7 @@ from comfy_cli.command.deploy_up import (
     landed_result,
     move_line,
     move_text,
+    observe_editor,
     reconcile_up,
     release_or_id,
     replaced_message,
@@ -358,6 +359,15 @@ def up_cmd(
             help="Name the deployment this creates. Default: production for a Build's first, else deployment-N.",
         ),
     ] = None,
+    editor: Annotated[
+        bool | None,
+        typer.Option(
+            "--editor/--no-editor",
+            help="Keep a CPU server for opening the deployment in the editor. Use --no-editor for one only called "
+            "through the API. Omitted, a new deployment gets comfy-deploy's default, on, and an existing one keeps "
+            "what it has.",
+        ),
+    ] = None,
     # Watching is what someone who just asked for a deployment wants: the command
     # that starts a several-minute wait should say how the wait is going. Ctrl-C
     # and --no-watch both leave the deploy running and print how to re-attach.
@@ -382,6 +392,7 @@ def up_cmd(
             deployment_id=deployment_id,
             create=create,
             name=name,
+            editor=editor,
             watch=watch,
         )
         try:
@@ -418,12 +429,16 @@ def up_cmd(
                 # process: report where it had got to, and leave it be.
                 _warn_unapplied_bounds(renderer, result)
                 if last is not None:
-                    _render_result(renderer, replace(result, deployment=last, pending_bounds=None), watch=False)
+                    abandoned_at = replace(result, deployment=last, pending_bounds=None)
+                    _render_result(renderer, observe_editor(abandoned_at, last), watch=False)
 
             move = watched_move(result.release, result.previous_release, result.deployment) if moving else None
             outcomes = MoveOutcomes(client, watched_id, move) if move is not None else None
             watched = _watch(renderer, client, watched_id, outcomes=outcomes, on_abandon=abandoned)
-            result = finish_move(client, result, watched, outcomes) if outcomes else replace(result, deployment=watched)
+            if outcomes is not None:
+                result = finish_move(client, result, watched, outcomes)
+            else:
+                result = observe_editor(replace(result, deployment=watched), watched)
         _render_result(renderer, result, watch=watch)
     except (BuildSpecNotFoundError, BuildSpecInvalidError) as error:
         _render_spec_error(renderer, error)

{comfy_cli-1.23.0 → comfy_cli-1.24.0}/comfy_cli/command/deploy_ls.py

@@ -54,6 +54,17 @@ def _release_column(deployment: JsonObject) -> str:
     return f"  {release_id}" if isinstance(release_id, str) and release_id else ""
 
 
+def _editor_of(row: JsonObject) -> bool | None:
+    # A comfy-deploy older than the editor switch sends no `editor`.
+    editor = row.get("editor")
+    return editor if isinstance(editor, bool) else None
+
+
+def _editor_column(deployment: JsonObject) -> str:
+    editor = deployment.get("editor")
+    return "" if editor is None else f"  editor {'on' if editor else 'off'}"
+
+
 def run_ls(request: ListRequest) -> None:
     renderer = get_renderer()
     try:
@@ -90,7 +101,7 @@ def run_ls(request: ListRequest) -> None:
                     version = versions[release_id]
                 if not request.include_deleted and row.get("deletedAt") is not None:
                     continue
-                named = {**row, "name": deployment_name(row)}
+                named = {**row, "name": deployment_name(row), "editor": _editor_of(row)}
                 deployments.append(named if version is None else {**named, "releaseVersion": version})
                 if len(deployments) == request.limit:
                     break
@@ -104,7 +115,8 @@ def run_ls(request: ListRequest) -> None:
                 marker = " (deleted)" if deployment.get("deletedAt") is not None else ""
                 renderer.print(
                     f"  {sanitize_markup(deployment['name'] or '-')}  {required_string(deployment, 'id')}"
-                    f"  {required_string(deployment, 'status')}{_release_column(deployment)}{marker}"
+                    f"  {required_string(deployment, 'status')}{_release_column(deployment)}"
+                    f"{_editor_column(deployment)}{marker}"
                 )
         payload_rows: list[JsonValue] = [*deployments]
         renderer.emit({"deployments": payload_rows}, command="deploy ls", changed=False)

{comfy_cli-1.23.0 → comfy_cli-1.24.0}/comfy_cli/command/deploy_types.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Final, Protocol
 
 from comfy_cli.command.build_spec import JsonObject, JsonValue
@@ -21,6 +21,7 @@ class DeployUpClient(Protocol):
         *,
         idempotency_key: str | None = None,
         name: str | None = None,
+        editor: bool | None = None,
     ) -> JsonObject: ...
 
     def get_deployment(self, deployment_id: str) -> JsonObject: ...
@@ -29,7 +30,11 @@ class DeployUpClient(Protocol):
 
     def start_deployment(self, deployment_id: str) -> JsonObject: ...
 
-    def move_deployment(self, deployment_id: str, base_revision: int, release_id: str) -> JsonObject: ...
+    def set_deployment_editor(self, deployment_id: str, editor: bool) -> JsonObject: ...
+
+    def move_deployment(
+        self, deployment_id: str, base_revision: int, release_id: str, *, editor: bool | None = None
+    ) -> JsonObject: ...
 
     def promote_deployment(self, deployment_id: str, base_revision: int, from_deployment_id: str) -> JsonObject: ...
 
@@ -59,12 +64,51 @@ class UpRequest:
     # `--name`: the name a created deployment gets, where comfy-deploy would
     # otherwise pick one.
     name: str | None = None
+    # `--editor/--no-editor`: whether the deployment keeps an editor CPU server.
+    # ``None`` is "flag omitted" and sends nothing: a create gets comfy-deploy's
+    # default, and an existing deployment keeps what it has.
+    editor: bool | None = None
     # Whether the caller follows the deployment once the request is accepted.
     # A move cannot carry new worker bounds, so they are applied after it lands,
     # and only a watch is there to see it land.
     watch: bool = True
 
 
+@dataclass(frozen=True, slots=True)
+class EditorCheck:
+    """Where `--editor/--no-editor` stands, judged apart from what else `up` did.
+
+    comfy-deploy keeps a move it took when the editor write fails, and leaves
+    `editor` out of an answer where its lookup of it fails, so neither ever
+    undoes the change it is judged beside.
+    """
+
+    requested: bool
+    # The value the latest answer that had one showed; None while none has.
+    seen: bool | None = None
+    # Set on an edit of the editor alone, of a deployment that had the other
+    # value: the value confirmed is then the change.
+    turns: bool = False
+    # Why the read made to confirm the value failed, until an answer shows it.
+    read_error: str | None = None
+
+    def observe(self, answer: JsonObject) -> EditorCheck:
+        """The check with the editor value ``answer`` shows, where it shows one."""
+        seen = answer.get("editor")
+        if not isinstance(seen, bool):
+            return self
+        return replace(self, seen=seen, read_error=None)
+
+    @property
+    def held(self) -> bool:
+        return self.seen is self.requested
+
+    @property
+    def made(self) -> bool:
+        """Whether the edit of the editor alone changed the deployment."""
+        return self.turns and self.held
+
+
 @dataclass(frozen=True, slots=True)
 class UpResult:
     deployment: JsonObject
@@ -91,6 +135,8 @@ class UpResult:
     pending_bounds: JsonObject | None = None
     # The name `--name` asked a create for, to say so where comfy-deploy took none.
     requested_name: str | None = None
+    # `--editor/--no-editor` as asked and as last read; None when neither was passed.
+    editor: EditorCheck | None = None
 
     def payload(self) -> JsonObject:
         supersedes: list[JsonValue] = [*self.supersedes]