Merge branch 'master' into mattmiller/spec-nullable-device-index-essentials-category

The previous description said "null for nodes that don't set
ESSENTIALS_CATEGORY (V1)" — that's wrong. server.py:739-740 uses
`hasattr` and OMITS the key when the V1 attribute isn't defined; null
only happens if the attribute is explicitly set to None. Spell out
all three legal shapes (string / null / absent) and which path
produces which.

.gitignore

@@ -23,4 +23,3 @@ web_custom_versions/
 .DS_Store
 filtered-openapi.yaml
 uv.lock
-.comfy_environment

comfy/cli_args.py

@@ -238,8 +238,6 @@ database_default_path = os.path.abspath(
 )
 parser.add_argument("--database-url", type=str, default=f"sqlite:///{database_default_path}", help="Specify the database URL, e.g. for an in-memory database you can use 'sqlite:///:memory:'.")
 parser.add_argument("--enable-assets", action="store_true", help="Enable the assets system (API routes, database synchronization, and background scanning).")
-parser.add_argument("--feature-flag", type=str, action='append', default=[], metavar="KEY[=VALUE]", help="Set a server feature flag. Use KEY=VALUE to set an explicit value, or bare KEY to set it to true. Can be specified multiple times. Boolean values (true/false) and numbers are auto-converted. Examples: --feature-flag show_signin_button=true  or  --feature-flag show_signin_button")
-parser.add_argument("--list-feature-flags", action="store_true", help="Print the registry of known CLI-settable feature flags as JSON and exit.")
 
 if comfy.options.args_parsing:
     args = parser.parse_args()

comfy/deploy_environment.py

@@ -1,34 +0,0 @@
-import functools
-import logging
-import os
-
-logger = logging.getLogger(__name__)
-
-_DEFAULT_DEPLOY_ENV = "local-git"
-_ENV_FILENAME = ".comfy_environment"
-
-# Resolve the ComfyUI install directory (the parent of this `comfy/` package).
-# We deliberately avoid `folder_paths.base_path` here because that is overridden
-# by the `--base-directory` CLI arg to a user-supplied path, whereas the
-# `.comfy_environment` marker is written by launchers/installers next to the
-# ComfyUI install itself.
-_COMFY_INSTALL_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-
-
-@functools.cache
-def get_deploy_environment() -> str:
-    env_file = os.path.join(_COMFY_INSTALL_DIR, _ENV_FILENAME)
-    try:
-        with open(env_file, encoding="utf-8") as f:
-            # Cap the read so a malformed or maliciously crafted file (e.g.
-            # a single huge line with no newline) can't blow up memory.
-            first_line = f.readline(128).strip()
-            value = "".join(c for c in first_line if 32 <= ord(c) < 127)
-            if value:
-                return value
-    except FileNotFoundError:
-        pass
-    except Exception as e:
-        logger.error("Failed to read %s: %s", env_file, e)
-
-    return _DEFAULT_DEPLOY_ENV

comfy_api/feature_flags.py

@@ -5,95 +5,12 @@ This module handles capability negotiation between frontend and backend,
 allowing graceful protocol evolution while maintaining backward compatibility.
 """
 
-import logging
-from typing import Any, TypedDict
+from typing import Any
 
 from comfy.cli_args import args
 
-
-class FeatureFlagInfo(TypedDict):
-    type: str
-    default: Any
-    description: str
-
-
-# Registry of known CLI-settable feature flags.
-# Launchers can query this via --list-feature-flags to discover valid flags.
-CLI_FEATURE_FLAG_REGISTRY: dict[str, FeatureFlagInfo] = {
-    "show_signin_button": {
-        "type": "bool",
-        "default": False,
-        "description": "Show the sign-in button in the frontend even when not signed in",
-    },
-}
-
-
-def _coerce_bool(v: str) -> bool:
-    """Strict bool coercion: only 'true'/'false' (case-insensitive).
-
-    Anything else raises ValueError so the caller can warn and drop the flag,
-    rather than silently treating typos like 'ture' or 'yes' as False.
-    """
-    lower = v.lower()
-    if lower == "true":
-        return True
-    if lower == "false":
-        return False
-    raise ValueError(f"expected 'true' or 'false', got {v!r}")
-
-
-_COERCE_FNS: dict[str, Any] = {
-    "bool": _coerce_bool,
-    "int": lambda v: int(v),
-    "float": lambda v: float(v),
-}
-
-
-def _coerce_flag_value(key: str, raw_value: str) -> Any:
-    """Coerce a raw string value using the registry type, or keep as string.
-
-    Returns the raw string if the key is unregistered or the type is unknown.
-    Raises ValueError/TypeError if the key is registered with a known type but
-    the value cannot be coerced; callers are expected to warn and drop the flag.
-    """
-    info = CLI_FEATURE_FLAG_REGISTRY.get(key)
-    if info is None:
-        return raw_value
-    coerce = _COERCE_FNS.get(info["type"])
-    if coerce is None:
-        return raw_value
-    return coerce(raw_value)
-
-
-def _parse_cli_feature_flags() -> dict[str, Any]:
-    """Parse --feature-flag key=value pairs from CLI args into a dict.
-
-    Items without '=' default to the value 'true' (bare flag form).
-    Flags whose value cannot be coerced to the registered type are dropped
-    with a warning, so a typo like '--feature-flag some_bool=ture' does not
-    silently take effect as the wrong value.
-    """
-    result: dict[str, Any] = {}
-    for item in getattr(args, "feature_flag", []):
-        key, sep, raw_value = item.partition("=")
-        key = key.strip()
-        if not key:
-            continue
-        if not sep:
-            raw_value = "true"
-        try:
-            result[key] = _coerce_flag_value(key, raw_value.strip())
-        except (ValueError, TypeError) as e:
-            info = CLI_FEATURE_FLAG_REGISTRY.get(key, {})
-            logging.warning(
-                "Could not coerce --feature-flag %s=%r to %s (%s); dropping flag.",
-                key, raw_value.strip(), info.get("type", "?"), e,
-            )
-    return result
-
-
 # Default server capabilities
-_CORE_FEATURE_FLAGS: dict[str, Any] = {
+SERVER_FEATURE_FLAGS: dict[str, Any] = {
     "supports_preview_metadata": True,
     "max_upload_size": args.max_upload_size * 1024 * 1024, # Convert MB to bytes
     "extension": {"manager": {"supports_v4": True}},
@@ -101,11 +18,6 @@ _CORE_FEATURE_FLAGS: dict[str, Any] = {
     "assets": args.enable_assets,
 }
 
-# CLI-provided flags cannot overwrite core flags
-_cli_flags = {k: v for k, v in _parse_cli_feature_flags().items() if k not in _CORE_FEATURE_FLAGS}
-
-SERVER_FEATURE_FLAGS: dict[str, Any] = {**_CORE_FEATURE_FLAGS, **_cli_flags}
-
 
 def get_connection_feature(
     sockets_metadata: dict[str, dict[str, Any]],

comfy_api_nodes/util/client.py

@@ -19,8 +19,6 @@ from comfy import utils
 from comfy_api.latest import IO
 from server import PromptServer
 
-from comfy.deploy_environment import get_deploy_environment
-
 from . import request_logger
 from ._helpers import (
     default_base_url,
@@ -626,7 +624,6 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
         payload_headers = {"Accept": "*/*"} if expect_binary else {"Accept": "application/json"}
         if not parsed_url.scheme and not parsed_url.netloc:  # is URL relative?
             payload_headers.update(get_auth_header(cfg.node_cls))
-            payload_headers["Comfy-Env"] = get_deploy_environment()
         if cfg.endpoint.headers:
             payload_headers.update(cfg.endpoint.headers)
 

main.py

@@ -1,21 +1,13 @@
 import comfy.options
 comfy.options.enable_args_parsing()
 
-from comfy.cli_args import args
-
-if args.list_feature_flags:
-    import json
-    from comfy_api.feature_flags import CLI_FEATURE_FLAG_REGISTRY
-    print(json.dumps(CLI_FEATURE_FLAG_REGISTRY, indent=2))  # noqa: T201
-    raise SystemExit(0)
-
 import os
 import importlib.util
 import shutil
 import importlib.metadata
 import folder_paths
 import time
-from comfy.cli_args import enables_dynamic_vram
+from comfy.cli_args import args, enables_dynamic_vram
 from app.logger import setup_logger
 setup_logger(log_level=args.verbose, use_stdout=args.log_stdout)
 

openapi.yaml

@@ -1999,26 +1999,6 @@ components:
           items:
             type: string
           description: List of node IDs to execute (partial graph execution)
-        workflow_id:
-          type: string
-          format: uuid
-          nullable: true
-          x-runtime: [cloud]
-          description: |
-            UUID identifying a hosted-cloud workflow entity to associate with this
-            job. Local ComfyUI doesn't track workflow entities and returns `null`
-            (or omits the field). The `x-runtime: [cloud]` extension marks this
-            as populated only by the hosted-cloud runtime; absence of the tag
-            means a field is populated by all runtimes.
-        workflow_version_id:
-          type: string
-          format: uuid
-          nullable: true
-          x-runtime: [cloud]
-          description: |
-            UUID identifying a hosted-cloud workflow version to associate with
-            this job. Local ComfyUI returns `null` (or omits the field). See
-            `workflow_id` above for `x-runtime` semantics.
 
     PromptResponse:
       type: object

tests-unit/deploy_environment_test.py

@@ -1,109 +0,0 @@
-"""Tests for comfy.deploy_environment."""
-
-import os
-
-import pytest
-
-from comfy import deploy_environment
-from comfy.deploy_environment import get_deploy_environment
-
-
-@pytest.fixture(autouse=True)
-def _reset_cache_and_install_dir(tmp_path, monkeypatch):
-    """Reset the functools cache and point the ComfyUI install dir at a tmp dir for each test."""
-    get_deploy_environment.cache_clear()
-    monkeypatch.setattr(deploy_environment, "_COMFY_INSTALL_DIR", str(tmp_path))
-    yield
-    get_deploy_environment.cache_clear()
-
-
-def _write_env_file(tmp_path, content: str) -> str:
-    """Write the env file with exact content (no newline translation).
-
-    `newline=""` disables Python's text-mode newline translation so the bytes
-    on disk match the literal string passed in, regardless of host OS.
-    Newline-style tests (CRLF, lone CR) rely on this.
-    """
-    path = os.path.join(str(tmp_path), ".comfy_environment")
-    with open(path, "w", encoding="utf-8", newline="") as f:
-        f.write(content)
-    return path
-
-
-class TestGetDeployEnvironment:
-    def test_returns_local_git_when_file_missing(self):
-        assert get_deploy_environment() == "local-git"
-
-    def test_reads_value_from_file(self, tmp_path):
-        _write_env_file(tmp_path, "local-desktop2-standalone\n")
-        assert get_deploy_environment() == "local-desktop2-standalone"
-
-    def test_strips_trailing_whitespace_and_newline(self, tmp_path):
-        _write_env_file(tmp_path, "  local-desktop2-standalone  \n")
-        assert get_deploy_environment() == "local-desktop2-standalone"
-
-    def test_only_first_line_is_used(self, tmp_path):
-        _write_env_file(tmp_path, "first-line\nsecond-line\n")
-        assert get_deploy_environment() == "first-line"
-
-    def test_crlf_line_ending(self, tmp_path):
-        # Windows editors often save text files with CRLF line endings.
-        # The CR must not end up in the returned value.
-        _write_env_file(tmp_path, "local-desktop2-standalone\r\n")
-        assert get_deploy_environment() == "local-desktop2-standalone"
-
-    def test_crlf_multiline_only_first_line_used(self, tmp_path):
-        _write_env_file(tmp_path, "first-line\r\nsecond-line\r\n")
-        assert get_deploy_environment() == "first-line"
-
-    def test_crlf_with_surrounding_whitespace(self, tmp_path):
-        _write_env_file(tmp_path, "  local-desktop2-standalone  \r\n")
-        assert get_deploy_environment() == "local-desktop2-standalone"
-
-    def test_lone_cr_line_ending(self, tmp_path):
-        # Classic-Mac / some legacy editors use a bare CR.
-        # Universal-newlines decoding treats it as a line terminator too.
-        _write_env_file(tmp_path, "local-desktop2-standalone\r")
-        assert get_deploy_environment() == "local-desktop2-standalone"
-
-    def test_empty_file_falls_back_to_default(self, tmp_path):
-        _write_env_file(tmp_path, "")
-        assert get_deploy_environment() == "local-git"
-
-    def test_empty_after_whitespace_strip_falls_back_to_default(self, tmp_path):
-        _write_env_file(tmp_path, "   \n")
-        assert get_deploy_environment() == "local-git"
-
-    def test_strips_control_chars_within_first_line(self, tmp_path):
-        # Embedded NUL/control chars in the value should be stripped
-        # (header-injection / smuggling protection).
-        _write_env_file(tmp_path, "abc\x00\x07xyz\n")
-        assert get_deploy_environment() == "abcxyz"
-
-    def test_strips_non_ascii_characters(self, tmp_path):
-        _write_env_file(tmp_path, "café-é\n")
-        assert get_deploy_environment() == "caf-"
-
-    def test_caps_read_at_128_bytes(self, tmp_path):
-        # A single huge line with no newline must not be fully read into memory.
-        huge = "x" * 10_000
-        _write_env_file(tmp_path, huge)
-        result = get_deploy_environment()
-        assert result == "x" * 128
-
-    def test_result_is_cached_across_calls(self, tmp_path):
-        path = _write_env_file(tmp_path, "first_value\n")
-        assert get_deploy_environment() == "first_value"
-        # Overwrite the file — cached value should still be returned.
-        with open(path, "w", encoding="utf-8") as f:
-            f.write("second_value\n")
-        assert get_deploy_environment() == "first_value"
-
-    def test_unreadable_file_falls_back_to_default(self, tmp_path, monkeypatch):
-        _write_env_file(tmp_path, "should_not_be_used\n")
-
-        def _boom(*args, **kwargs):
-            raise OSError("simulated read failure")
-
-        monkeypatch.setattr("builtins.open", _boom)
-        assert get_deploy_environment() == "local-git"

tests-unit/feature_flags_test.py

@@ -1,15 +1,10 @@
 """Tests for feature flags functionality."""
 
-import pytest
-
 from comfy_api.feature_flags import (
     get_connection_feature,
     supports_feature,
     get_server_features,
-    CLI_FEATURE_FLAG_REGISTRY,
     SERVER_FEATURE_FLAGS,
-    _coerce_flag_value,
-    _parse_cli_feature_flags,
 )
 
 
@@ -101,83 +96,3 @@ class TestFeatureFlags:
         result = get_connection_feature(sockets_metadata, "sid1", "any_feature")
         assert result is False
         assert supports_feature(sockets_metadata, "sid1", "any_feature") is False
-
-
-class TestCoerceFlagValue:
-    """Test suite for _coerce_flag_value."""
-
-    def test_registered_bool_true(self):
-        assert _coerce_flag_value("show_signin_button", "true") is True
-        assert _coerce_flag_value("show_signin_button", "True") is True
-
-    def test_registered_bool_false(self):
-        assert _coerce_flag_value("show_signin_button", "false") is False
-        assert _coerce_flag_value("show_signin_button", "FALSE") is False
-
-    def test_unregistered_key_stays_string(self):
-        assert _coerce_flag_value("unknown_flag", "true") == "true"
-        assert _coerce_flag_value("unknown_flag", "42") == "42"
-
-    def test_bool_typo_raises(self):
-        """Strict bool: typos like 'ture' or 'yes' must raise so the flag can be dropped."""
-        with pytest.raises(ValueError):
-            _coerce_flag_value("show_signin_button", "ture")
-        with pytest.raises(ValueError):
-            _coerce_flag_value("show_signin_button", "yes")
-        with pytest.raises(ValueError):
-            _coerce_flag_value("show_signin_button", "1")
-        with pytest.raises(ValueError):
-            _coerce_flag_value("show_signin_button", "")
-
-    def test_failed_int_coercion_raises(self, monkeypatch):
-        """Malformed values for typed flags must raise; caller decides what to do."""
-        monkeypatch.setitem(
-            CLI_FEATURE_FLAG_REGISTRY,
-            "test_int_flag",
-            {"type": "int", "default": 0, "description": "test"},
-        )
-        with pytest.raises(ValueError):
-            _coerce_flag_value("test_int_flag", "not_a_number")
-
-
-class TestParseCliFeatureFlags:
-    """Test suite for _parse_cli_feature_flags."""
-
-    def test_single_flag(self, monkeypatch):
-        monkeypatch.setattr("comfy_api.feature_flags.args", type("Args", (), {"feature_flag": ["show_signin_button=true"]})())
-        result = _parse_cli_feature_flags()
-        assert result == {"show_signin_button": True}
-
-    def test_missing_equals_defaults_to_true(self, monkeypatch):
-        """Bare flag without '=' is treated as the string 'true' (and coerced if registered)."""
-        monkeypatch.setattr("comfy_api.feature_flags.args", type("Args", (), {"feature_flag": ["show_signin_button", "valid=1"]})())
-        result = _parse_cli_feature_flags()
-        assert result == {"show_signin_button": True, "valid": "1"}
-
-    def test_empty_key_skipped(self, monkeypatch):
-        monkeypatch.setattr("comfy_api.feature_flags.args", type("Args", (), {"feature_flag": ["=value", "valid=1"]})())
-        result = _parse_cli_feature_flags()
-        assert result == {"valid": "1"}
-
-    def test_invalid_bool_value_dropped(self, monkeypatch, caplog):
-        """A typo'd bool value must be dropped entirely, not silently set to False
-        and not stored as a raw string. A warning must be logged."""
-        monkeypatch.setattr(
-            "comfy_api.feature_flags.args",
-            type("Args", (), {"feature_flag": ["show_signin_button=ture", "valid=1"]})(),
-        )
-        with caplog.at_level("WARNING"):
-            result = _parse_cli_feature_flags()
-        assert result == {"valid": "1"}
-        assert "show_signin_button" not in result
-        assert any("show_signin_button" in r.message and "drop" in r.message.lower() for r in caplog.records)
-
-
-class TestCliFeatureFlagRegistry:
-    """Test suite for the CLI feature flag registry."""
-
-    def test_registry_entries_have_required_fields(self):
-        for key, info in CLI_FEATURE_FLAG_REGISTRY.items():
-            assert "type" in info, f"{key} missing 'type'"
-            assert "default" in info, f"{key} missing 'default'"
-            assert "description" in info, f"{key} missing 'description'"