comfy-cli 1.10.0__tar.gz → 1.10.2__tar.gz

{comfy_cli-1.10.0 → comfy_cli-1.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-cli
-Version: 1.10.0
+Version: 1.10.2
 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
@@ -24,6 +24,7 @@ Requires-Dist: httpx
 Requires-Dist: mixpanel
 Requires-Dist: packaging
 Requires-Dist: pathspec
+Requires-Dist: posthog<8,>=6
 Requires-Dist: psutil
 Requires-Dist: pyyaml
 Requires-Dist: questionary

{comfy_cli-1.10.0 → comfy_cli-1.10.2}/comfy_cli/cmdline.py

@@ -423,10 +423,24 @@ def update(
         rprint(f"[yellow]Failed to update node id cache: {e}[/yellow]")
 
 
-@app.command(help="Run API workflow file using the ComfyUI launched by `comfy launch --background`")
-@tracking.track_command()
+@app.command(
+    help=(
+        "Run a workflow on the ComfyUI launched by `comfy launch --background`. "
+        "Accepts both ComfyUI API format and exported UI workflow JSON; "
+        "UI workflows are converted to API format client-side via /object_info."
+    )
+)
 def run(
-    workflow: Annotated[str, typer.Option(help="Path to the workflow API json file.")],
+    workflow: Annotated[
+        str,
+        typer.Option(
+            help=(
+                "Path to the workflow JSON file. Both ComfyUI API format and "
+                "exported UI format are accepted; UI workflows are converted "
+                "to API format client-side."
+            )
+        ),
+    ],
     wait: Annotated[
         bool,
         typer.Option(help="If the command should wait until execution completes."),
@@ -444,9 +458,17 @@ def run(
         typer.Option(help="The port where the ComfyUI instance is running, e.g. 8188."),
     ] = None,
     timeout: Annotated[
-        int | None,
-        typer.Option(help="The timeout in seconds for the workflow execution."),
-    ] = 30,
+        int,
+        typer.Option(
+            help=(
+                "Per-event timeout in seconds: bails out if the server is silent "
+                "for this long. Also caps HTTP connect, /prompt POST, and websocket "
+                "handshake. NOT a wall-clock execution deadline — a workflow that "
+                "streams progress events faster than the timeout can run "
+                "indefinitely."
+            ),
+        ),
+    ] = 120,
     api_key: Annotated[
         str | None,
         typer.Option(
@@ -454,40 +476,99 @@ def run(
             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. "
+                "Embedded in the POST /prompt request body as extra_data.api_key_comfy_org. "
                 "For scripting, prefer the COMFY_API_KEY environment variable so the secret "
                 "stays out of shell history."
             ),
         ),
     ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option(
+            "--json",
+            help=(
+                "Emit NDJSON events to stdout instead of human-readable output. "
+                "One JSON object per line, terminated by \\n. See docs/json-output.md "
+                "for the event reference and stability contract. In this mode, "
+                "--verbose has no effect and Rich progress is suppressed. "
+                "Workflow input accepts both API and UI format JSON (UI input "
+                "triggers a `converted` event before `queued`). The converted "
+                "workflow graph is always emitted as a `prompt_preview` event "
+                "before `queued`, so agents have a full audit trail of what "
+                "the CLI submitted."
+            ),
+        ),
+    ] = False,
+    print_prompt: Annotated[
+        bool,
+        typer.Option(
+            "--print-prompt",
+            help=(
+                "Print the API-format workflow graph that WOULD be sent to /prompt and exit. "
+                "Does not POST and does not execute. For UI-format input the workflow is "
+                "converted first (requires a reachable ComfyUI for /object_info); API input "
+                "is printed as-is with no server hit. In --json mode emits a `prompt_preview` "
+                "event; otherwise pretty-prints to stdout."
+            ),
+        ),
+    ] = False,
 ):
-    if api_key:
-        api_key = api_key.strip() or 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()))
+    tracking.track_event("execution_start", _track_props, mixpanel_name="run")
 
-    config = ConfigManager()
+    try:
+        if api_key:
+            api_key = api_key.strip() or None
 
-    if host:
-        s = host.split(":")
-        host = s[0]
-        if not port and len(s) == 2:
-            port = int(s[1])
+        config = ConfigManager()
 
-    local_paths = False
-    if config.background:
-        if not host:
-            host = config.background[0]
-            local_paths = True
-        if port:
-            local_paths = False
-        else:
-            port = config.background[1]
+        if host:
+            s = host.split(":")
+            host = s[0]
+            if not port and len(s) == 2:
+                port = int(s[1])
 
-    if not host:
-        host = "127.0.0.1"
-    if not port:
-        port = 8188
+        if config.background:
+            bg_host, bg_port = config.background[0], config.background[1]
+            if not host:
+                host = bg_host
+            if not port:
+                port = bg_port
 
-    run_inner.execute(workflow, host, port, wait, verbose, local_paths, timeout, api_key=api_key)
+        if not host:
+            host = "127.0.0.1"
+        if not port:
+            port = 8188
+
+        run_inner.execute(
+            workflow,
+            host,
+            port,
+            wait,
+            verbose,
+            timeout,
+            api_key=api_key,
+            json_mode=json_output,
+            print_prompt=print_prompt,
+        )
+    except typer.Exit as e:
+        if (e.exit_code or 0) == 0:
+            tracking.track_event("execution_success", _track_props)
+        else:
+            tracking.track_event(
+                "execution_error",
+                {**_track_props, "error_type": type(e).__name__, "exit_code": e.exit_code},
+            )
+        raise
+    except Exception as e:
+        tracking.track_event(
+            "execution_error",
+            {**_track_props, "error_type": type(e).__name__},
+        )
+        raise
+    else:
+        tracking.track_event("execution_success", _track_props)
 
 
 def validate_comfyui(_env_checker):

{comfy_cli-1.10.0 → comfy_cli-1.10.2}/comfy_cli/command/generate/app.py

@@ -43,7 +43,6 @@ def register_with(parent: typer.Typer) -> None:
     subcommand name and error."""
 
     @parent.command(name="generate", help=_HELP, context_settings=_CONTEXT_SETTINGS)
-    @tracking.track_command()
     def _generate_entry(
         ctx: typer.Context,
         target: Annotated[
@@ -57,17 +56,29 @@ def register_with(parent: typer.Typer) -> None:
         if target is None or target in {"-h", "--help"}:
             _print_top_help()
             raise typer.Exit(code=0)
+        extra = list(ctx.args)
         if target == "list":
-            return _list_models(list(ctx.args))
+            tracking.track_event("generate:list")
+            return _list_models(extra)
         if target == "schema":
-            return _schema(list(ctx.args))
+            model_arg = extra[0] if extra and not extra[0].startswith("-") else None
+            tracking.track_event("generate:schema", {"model": model_arg})
+            return _schema(extra)
         if target == "refresh":
+            tracking.track_event("generate:refresh")
             return _refresh()
         if target == "upload":
-            return _upload(list(ctx.args))
+            tracking.track_event("generate:upload")
+            return _upload(extra)
         if target == "resume":
-            return _resume(list(ctx.args))
-        _generate(target, list(ctx.args))
+            resume_model = extra[0] if extra and not extra[0].startswith("-") else None
+            resume_job_id = extra[1] if len(extra) >= 2 and not extra[1].startswith("-") else None
+            tracking.track_event(
+                "generate:resume",
+                {"model": resume_model, "job_id": resume_job_id},
+            )
+            return _resume(extra)
+        _generate(target, extra)
 
 
 def _separate_meta_flags(extra_args: list[str]) -> tuple[list[str], dict[str, str | bool]]:
@@ -146,130 +157,214 @@ def _emit_result(result: poll.PollResult, *, request_id: str, download: str | No
 
 
 def _generate(model: str, extra_args: list[str]) -> None:
-    try:
-        ep = spec.get_endpoint(model)
-    except spec.SpecError as e:
-        rprint(f"[bold red]{e}[/bold red]")
-        raise typer.Exit(code=1)
-
-    if any(a in {"--help", "-h"} for a in extra_args):
-        _show_schema_help(ep)
-        raise typer.Exit(code=0)
-
-    try:
-        remaining, meta = _separate_meta_flags(extra_args)
-    except schema.SchemaError as e:
-        rprint(f"[bold red]{e}[/bold red]")
-        raise typer.Exit(code=1)
-
-    flags = schema.flags_for(ep)
-    try:
-        values = schema.parse_args(flags, remaining)
-    except schema.SchemaError as e:
-        rprint(f"[bold red]{e}[/bold red]")
-        name = spec.preferred_alias(ep.id) or ep.id
-        rprint(f"[dim]Run `comfy generate schema {name}` for the full parameter list.[/dim]")
-        raise typer.Exit(code=1)
-
-    try:
-        api_key = client.resolve_api_key(meta.get("api-key") if isinstance(meta.get("api-key"), str) else None)
-    except client.ApiError as e:
-        rprint(f"[bold red]{e}[/bold red]")
-        raise typer.Exit(code=1)
-
-    timeout_raw = meta.get("timeout", "300")
-    try:
-        timeout = float(timeout_raw) if isinstance(timeout_raw, str) else 300.0
-    except ValueError:
-        rprint(f"[bold red]--timeout: expected number, got {timeout_raw!r}[/bold red]")
-        raise typer.Exit(code=1)
-
-    do_async = bool(meta.get("async", False))
-    download = meta.get("download") if isinstance(meta.get("download"), str) else None
-    as_json = bool(meta.get("json", False))
-
-    try:
-        _apply_upload_transforms(values, flags, ep, api_key)
-    except (client.ApiError, httpx.HTTPError) as e:
-        rprint(f"[bold red]Upload failed: {e}[/bold red]")
-        raise typer.Exit(code=1)
+    # --help short-circuits before tracking — it's a help-display action, not an execution attempt.
+    # If the model is unknown, fall through so the tracking path records the schema error.
+    asks_help = any(a in {"--help", "-h"} for a in extra_args)
+    if asks_help:
+        try:
+            help_ep = spec.get_endpoint(model)
+        except spec.SpecError:
+            help_ep = None
+        if help_ep is not None:
+            _show_schema_help(help_ep)
+            raise typer.Exit(code=0)
 
-    request_id = str(uuid.uuid4())[:8]
-    try:
-        resp = client.send_request(ep, values, flags, api_key, timeout=timeout)
-    except httpx.HTTPError as e:
-        rprint(f"[bold red]Network error contacting {spec.base_url()}: {e}[/bold red]")
-        raise typer.Exit(code=1) from e
+    # generate:start fires at entry so every invocation has a paired start/end lifecycle.
+    # Props are filled in progressively as model_alias / partner / async / has_download become known.
+    gen_props: dict[str, object | None] = {
+        "model": model,
+        "model_alias": None,
+        "async": None,
+        "has_download": None,
+        "partner": None,
+    }
+    tracking.track_event("generate:start", gen_props)
+
+    def _track_error(error_kind: str, exc: BaseException) -> None:
+        tracking.track_event(
+            "generate:error",
+            {**gen_props, "error_type": type(exc).__name__, "error_kind": error_kind},
+        )
 
     try:
-        client.raise_for_status(resp)
-    except client.ApiError as e:
-        rprint(f"[bold red]API error {e.status}[/bold red]\n{e.body}")
-        raise typer.Exit(code=1) from e
-
-    if resp.headers.get("content-type", "").startswith("image/"):
-        if download:
-            saved = output.save_binary_response(resp, download, request_id)
-            output.print_saved([saved])
-        else:
-            rprint("[yellow]Binary image response; nothing saved. Pass --download <path> to write it to disk.[/yellow]")
-        return
+        try:
+            ep = spec.get_endpoint(model)
+        except spec.SpecError as e:
+            rprint(f"[bold red]{e}[/bold red]")
+            _track_error("schema", e)
+            raise typer.Exit(code=1)
+
+        gen_props["model_alias"] = spec.preferred_alias(ep.id)
+        gen_props["partner"] = getattr(ep, "partner", None)
+
+        try:
+            remaining, meta = _separate_meta_flags(extra_args)
+        except schema.SchemaError as e:
+            rprint(f"[bold red]{e}[/bold red]")
+            _track_error("schema", e)
+            raise typer.Exit(code=1)
+
+        do_async = bool(meta.get("async", False))
+        download = meta.get("download") if isinstance(meta.get("download"), str) else None
+        as_json = bool(meta.get("json", False))
+        gen_props["async"] = do_async
+        gen_props["has_download"] = bool(download)
+
+        flags = schema.flags_for(ep)
+        try:
+            values = schema.parse_args(flags, remaining)
+        except schema.SchemaError as e:
+            rprint(f"[bold red]{e}[/bold red]")
+            name = gen_props["model_alias"] or ep.id
+            rprint(f"[dim]Run `comfy generate schema {name}` for the full parameter list.[/dim]")
+            _track_error("schema", e)
+            raise typer.Exit(code=1)
+
+        try:
+            api_key = client.resolve_api_key(meta.get("api-key") if isinstance(meta.get("api-key"), str) else None)
+        except client.ApiError as e:
+            rprint(f"[bold red]{e}[/bold red]")
+            _track_error("api", e)
+            raise typer.Exit(code=1)
+
+        timeout_raw = meta.get("timeout", "300")
+        try:
+            timeout = float(timeout_raw) if isinstance(timeout_raw, str) else 300.0
+        except ValueError as e:
+            rprint(f"[bold red]--timeout: expected number, got {timeout_raw!r}[/bold red]")
+            _track_error("schema", e)
+            raise typer.Exit(code=1)
+
+        try:
+            _apply_upload_transforms(values, flags, ep, api_key)
+        except (client.ApiError, httpx.HTTPError) as e:
+            rprint(f"[bold red]Upload failed: {e}[/bold red]")
+            _track_error("upload", e)
+            raise typer.Exit(code=1)
+
+        request_id = str(uuid.uuid4())[:8]
+        try:
+            resp = client.send_request(ep, values, flags, api_key, timeout=timeout)
+        except httpx.HTTPError as e:
+            rprint(f"[bold red]Network error contacting {spec.base_url()}: {e}[/bold red]")
+            _track_error("network", e)
+            raise typer.Exit(code=1) from e
+
+        try:
+            client.raise_for_status(resp)
+        except client.ApiError as e:
+            rprint(f"[bold red]API error {e.status}[/bold red]\n{e.body}")
+            _track_error("api", e)
+            raise typer.Exit(code=1) from e
+
+        if resp.headers.get("content-type", "").startswith("image/"):
+            if download:
+                saved = output.save_binary_response(resp, download, request_id)
+                output.print_saved([saved])
+            else:
+                rprint(
+                    "[yellow]Binary image response; nothing saved. Pass --download <path> to write it to disk.[/yellow]"
+                )
+            tracking.track_event("generate:success", gen_props)
+            return
 
-    try:
-        body = resp.json()
-    except ValueError:
-        rprint("[bold red]Unexpected non-JSON response.[/bold red]")
-        rprint(resp.text[:500])
-        raise typer.Exit(code=1)
+        try:
+            body = resp.json()
+        except ValueError as e:
+            rprint("[bold red]Unexpected non-JSON response.[/bold red]")
+            rprint(resp.text[:500])
+            _track_error("non_json_response", e)
+            raise typer.Exit(code=1)
+
+        if ep.polling:
+            job_id = poll.extract_job_id(ep.polling, body) or request_id
+            name = gen_props["model_alias"] or ep.id
+            if do_async:
+                if as_json:
+                    output.print_json(body)
+                else:
+                    rprint(f"[bold green]Submitted:[/bold green] {name}")
+                    rprint(f"  job id: {job_id}")
+                    rprint(f"  resume: comfy generate resume {name} {job_id}")
+                # Submitted, not succeeded — the workflow runs on the partner side and completion is
+                # observed server-side via partner_node:api_call_*. No generate:success pair here.
+                tracking.track_event(
+                    "generate:submitted",
+                    {
+                        "model": model,
+                        "model_alias": gen_props["model_alias"],
+                        "job_id": job_id,
+                        "partner": gen_props["partner"],
+                    },
+                )
+                return
+
+            poller = poll.get_poller(ep.polling)
+            with _spinner() as prog:
+                task = prog.add_task(f"Generating with {name} (job {job_id})", total=None)
+
+                def _on_progress(p: float) -> None:
+                    prog.update(task, description=f"Generating ({p * 100:.0f}%)")
+
+                try:
+                    result = poller(
+                        body,
+                        api_key=api_key,
+                        timeout=timeout,
+                        on_progress=_on_progress,
+                        create_path=ep.path,
+                    )
+                except (client.ApiError, httpx.HTTPError) as e:
+                    _track_error("network" if isinstance(e, httpx.HTTPError) else "api", e)
+                    raise typer.Exit(code=1) from e
+            try:
+                _emit_result(result, request_id=job_id, download=download, as_json=as_json)
+                tracking.track_event("generate:success", gen_props)
+            except typer.Exit as e:
+                if (e.exit_code or 0) == 0:
+                    tracking.track_event("generate:success", gen_props)
+                else:
+                    _track_error("api", e)
+                raise
+            return
 
-    if ep.polling:
-        job_id = poll.extract_job_id(ep.polling, body) or request_id
-        name = spec.preferred_alias(ep.id) or ep.id
-        if do_async:
+        adapter = adapters.get(ep.id)
+        if adapter is not None and adapter.decode_sync is not None:
+            body = resp.json()
             if as_json:
                 output.print_json(body)
+                tracking.track_event("generate:success", gen_props)
+                return
+            if not download:
+                rprint("[yellow]Image data returned inline. Pass --download <path> to save.[/yellow]")
+                tracking.track_event("generate:success", gen_props)
+                return
+            saved = adapter.decode_sync(body, download, request_id)
+            if saved:
+                output.print_saved(saved)
             else:
-                rprint(f"[bold green]Submitted:[/bold green] {name}")
-                rprint(f"  job id: {job_id}")
-                rprint(f"  resume: comfy generate resume {name} {job_id}")
-            return
-
-        poller = poll.get_poller(ep.polling)
-        with _spinner() as prog:
-            task = prog.add_task(f"Generating with {name} (job {job_id})", total=None)
-
-            def _on_progress(p: float) -> None:
-                prog.update(task, description=f"Generating ({p * 100:.0f}%)")
-
-            result = poller(
-                body,
-                api_key=api_key,
-                timeout=timeout,
-                on_progress=_on_progress,
-                create_path=ep.path,
-            )
-        _emit_result(result, request_id=job_id, download=download, as_json=as_json)
-        return
-
-    adapter = adapters.get(ep.id)
-    if adapter is not None and adapter.decode_sync is not None:
-        body = resp.json()
-        if as_json:
-            output.print_json(body)
-            return
-        if not download:
-            rprint("[yellow]Image data returned inline. Pass --download <path> to save.[/yellow]")
+                rprint("[yellow]No image data found in response.[/yellow]")
+                output.print_json(body)
+            tracking.track_event("generate:success", gen_props)
             return
-        saved = adapter.decode_sync(body, download, request_id)
-        if saved:
-            output.print_saved(saved)
-        else:
-            rprint("[yellow]No image data found in response.[/yellow]")
-            output.print_json(body)
-        return
 
-    result = poll.sync_result_from_response(resp)
-    _emit_result(result, request_id=request_id, download=download, as_json=as_json)
+        try:
+            result = poll.sync_result_from_response(resp)
+            _emit_result(result, request_id=request_id, download=download, as_json=as_json)
+            tracking.track_event("generate:success", gen_props)
+        except typer.Exit as e:
+            if (e.exit_code or 0) == 0:
+                tracking.track_event("generate:success", gen_props)
+            else:
+                _track_error("api", e)
+            raise
+    except typer.Exit:
+        # Inline raise sites already emitted their lifecycle event.
+        raise
+    except Exception as e:
+        # Safety net so an unexpected exception still pairs generate:start with a terminal generate:error.
+        _track_error("unknown", e)
+        raise
 
 
 def _arg_value(args: list[str], *names: str) -> str | None:
@@ -410,7 +505,7 @@ def _apply_upload_transforms(values: dict, flags: list[schema.FlagDef], endpoint
 
 
 def _resume(extra_args: list[str]) -> None:
-    if len(extra_args) < 2:
+    if len(extra_args) < 2 or extra_args[0].startswith("-") or extra_args[1].startswith("-"):
         rprint("[bold red]Usage: comfy generate resume <model> <job_id> [--download PATH] [--json][/bold red]")
         raise typer.Exit(code=1)
     model, job_id = extra_args[0], extra_args[1]