Add colored logs option.

app/logger.py

@@ -5,6 +5,24 @@ import logging
 import sys
 import threading
 
+ANSI_LEVEL_COLORS = {
+    'DEBUG':    '\033[36m',   # cyan
+    'INFO':     '\033[32m',   # green
+    'WARNING':  '\033[33m',   # yellow
+    'ERROR':    '\033[31m',   # red
+    'CRITICAL': '\033[35m',   # magenta
+}
+ANSI_RESET = '\033[0m'
+ANSI_BOLD  = '\033[1m'
+
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        color = ANSI_LEVEL_COLORS.get(record.levelname, '')
+        bold  = ANSI_BOLD if record.levelno >= logging.WARNING else ''
+        level_tag = f"{bold}{color}[{record.levelname}]{ANSI_RESET} "
+        return level_tag + super().format(record)
+
 logs = None
 stdout_interceptor = None
 stderr_interceptor = None
@@ -51,7 +69,7 @@ def on_flush(callback):
     if stderr_interceptor is not None:
         stderr_interceptor.on_flush(callback)
 
-def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool = False):
+def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool = False, color_logs: bool = False):
     global logs
     if logs:
         return
@@ -68,8 +86,10 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool
     logger = logging.getLogger()
     logger.setLevel(log_level)
 
+    formatter = ColoredFormatter("%(message)s") if color_logs else logging.Formatter("%(message)s")
+
     stream_handler = logging.StreamHandler()
-    stream_handler.setFormatter(logging.Formatter("%(message)s"))
+    stream_handler.setFormatter(formatter)
 
     if use_stdout:
         # Only errors and critical to stderr
@@ -77,7 +97,7 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool
 
         # Lesser to stdout
         stdout_handler = logging.StreamHandler(sys.stdout)
-        stdout_handler.setFormatter(logging.Formatter("%(message)s"))
+        stdout_handler.setFormatter(formatter)
         stdout_handler.addFilter(lambda record: record.levelno < logging.ERROR)
         logger.addHandler(stdout_handler)
 

comfy/cli_args.py

@@ -183,6 +183,7 @@ parser.add_argument("--multi-user", action="store_true", help="Enables per-user
 
 parser.add_argument("--verbose", default='INFO', const='DEBUG', nargs="?", choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], help='Set the logging level')
 parser.add_argument("--log-stdout", action="store_true", help="Send normal process output to stdout instead of stderr (default).")
+parser.add_argument("--color-logs", action="store_true", help="Enable ANSI colored log output in the terminal.")
 
 
 # The default built-in provider hosted under web/

main.py

@@ -17,7 +17,7 @@ import folder_paths
 import time
 from comfy.cli_args import enables_dynamic_vram
 from app.logger import setup_logger
-setup_logger(log_level=args.verbose, use_stdout=args.log_stdout)
+setup_logger(log_level=args.verbose, use_stdout=args.log_stdout, color_logs=args.color_logs)
 
 from app.assets.seeder import asset_seeder
 from app.assets.services import register_output_files
@@ -27,7 +27,6 @@ from utils.mime_types import init_mime_types
 import faulthandler
 import logging
 import sys
-import traceback
 from comfy_execution.progress import get_progress_state
 from comfy_execution.utils import get_executing_context
 from comfy_api import feature_flags
@@ -136,20 +135,7 @@ def apply_custom_paths():
         folder_paths.set_user_directory(user_dir)
 
 
-# Buffer for prestartup failures. Recorded into `nodes.NODE_STARTUP_ERRORS`
-# only AFTER the normal `import nodes` line below, so a failing prestartup
-# script never triggers an early `import nodes` (and therefore `import torch`)
-# on the error path.
-_PRESTARTUP_FAILURES: list[dict] = []
-
-
 def execute_prestartup_script():
-    """Run every custom_nodes/*/prestartup_script.py once, before importing nodes.
-
-    Failures are buffered into the module-level ``_PRESTARTUP_FAILURES`` list and
-    must be flushed via ``record_node_startup_error`` after ``import nodes`` has
-    happened at its normal bootstrap point.
-    """
     if args.disable_all_custom_nodes and len(args.whitelist_custom_nodes) == 0:
         return
 
@@ -162,15 +148,6 @@ def execute_prestartup_script():
             return True
         except Exception as e:
             logging.error(f"Failed to execute startup-script: {script_path} / {e}")
-            # Buffer the failure - do NOT `import nodes` here, that would drag
-            # torch in before the intended bootstrap point.
-            _PRESTARTUP_FAILURES.append({
-                "module_path": os.path.dirname(script_path),
-                "source": "custom_nodes",
-                "phase": "prestartup",
-                "error": e,
-                "tb": traceback.format_exc(),
-            })
         return False
 
     node_paths = folder_paths.get_folder_paths("custom_nodes")
@@ -230,16 +207,6 @@ import execution
 import server
 from protocol import BinaryEventTypes
 import nodes
-
-# Flush any prestartup failures that were buffered before `nodes` was
-# importable. Doing this here (rather than from the prestartup error
-# handler) keeps the bootstrap order deterministic: `nodes` (and torch)
-# import at this single line whether prestartup succeeded or failed.
-if _PRESTARTUP_FAILURES:
-    for _failure in _PRESTARTUP_FAILURES:
-        nodes.record_node_startup_error(**_failure)
-    _PRESTARTUP_FAILURES.clear()
-
 import comfy.model_management
 import comfyui_version
 import app.logger

nodes.py

@@ -2158,71 +2158,6 @@ EXTENSION_WEB_DIRS = {}
 # Dictionary of successfully loaded module names and associated directories.
 LOADED_MODULE_DIRS = {}
 
-# Dictionary of custom node startup errors, keyed by "<source>:<module_name>"
-# so that name collisions across custom_nodes / comfy_extras / comfy_api_nodes
-# do not overwrite each other. Each value contains: source, module_name,
-# module_path, error, traceback, phase.
-#
-# `source` is the same string as the internal `module_parent` used at load
-# time (e.g. "custom_nodes", "comfy_extras", "comfy_api_nodes"). It is
-# intentionally a free-form string rather than a fixed enum so the contract
-# survives node-source layouts evolving (e.g. comfy_api_nodes eventually
-# moving out of core). Consumers should treat any new value as a new bucket
-# rather than rejecting it.
-NODE_STARTUP_ERRORS: dict[str, dict] = {}
-
-
-def _read_pyproject_metadata(module_path: str) -> dict | None:
-    """Best-effort extraction of node-pack identity from pyproject.toml.
-
-    Returns a dict with the Comfy Registry-style identity (pack_id,
-    display_name, publisher_id, version, repository) when the module
-    directory contains a pyproject.toml. Returns None when no toml is
-    present or parsing fails for any reason — startup-error tracking
-    must never itself raise.
-    """
-    if not module_path or not os.path.isdir(module_path):
-        return None
-    toml_path = os.path.join(module_path, "pyproject.toml")
-    if not os.path.isfile(toml_path):
-        return None
-    try:
-        from comfy_config import config_parser
-
-        cfg = config_parser.extract_node_configuration(module_path)
-        if cfg is None:
-            return None
-        meta = {
-            "pack_id": cfg.project.name or None,
-            "display_name": cfg.tool_comfy.display_name or None,
-            "publisher_id": cfg.tool_comfy.publisher_id or None,
-            "version": cfg.project.version or None,
-            "repository": cfg.project.urls.repository or None,
-        }
-        # Drop empty fields so the API payload stays compact.
-        return {k: v for k, v in meta.items() if v}
-    except Exception:
-        return None
-
-
-def record_node_startup_error(
-    *, module_path: str, source: str, phase: str, error: BaseException, tb: str
-) -> None:
-    """Record a startup error for a node module so it can be exposed via the API."""
-    module_name = get_module_name(module_path)
-    entry = {
-        "source": source,
-        "module_name": module_name,
-        "module_path": module_path,
-        "error": str(error),
-        "traceback": tb,
-        "phase": phase,
-    }
-    pyproject = _read_pyproject_metadata(module_path)
-    if pyproject:
-        entry["pyproject"] = pyproject
-    NODE_STARTUP_ERRORS[f"{source}:{module_name}"] = entry
-
 
 def get_module_name(module_path: str) -> str:
     """
@@ -2332,30 +2267,14 @@ async def load_custom_node(module_path: str, ignore=set(), module_parent="custom
                         NODE_DISPLAY_NAME_MAPPINGS[schema.node_id] = schema.display_name
                 return True
             except Exception as e:
-                tb = traceback.format_exc()
                 logging.warning(f"Error while calling comfy_entrypoint in {module_path}: {e}")
-                record_node_startup_error(
-                    module_path=module_path,
-                    source=module_parent,
-                    phase="entrypoint",
-                    error=e,
-                    tb=tb,
-                )
                 return False
         else:
             logging.warning(f"Skip {module_path} module for custom nodes due to the lack of NODE_CLASS_MAPPINGS or comfy_entrypoint (need one).")
             return False
     except Exception as e:
-        tb = traceback.format_exc()
-        logging.warning(tb)
+        logging.warning(traceback.format_exc())
         logging.warning(f"Cannot import {module_path} module for custom nodes: {e}")
-        record_node_startup_error(
-            module_path=module_path,
-            source=module_parent,
-            phase="import",
-            error=e,
-            tb=tb,
-        )
         return False
 
 async def init_external_custom_nodes():

server.py

@@ -765,29 +765,6 @@ class PromptServer():
                 out[node_class] = node_info(node_class)
             return web.json_response(out)
 
-        @routes.get("/node_startup_errors")
-        async def get_node_startup_errors(request):
-            """Return startup errors recorded during node loading, grouped by source.
-
-            Group errors by source so the frontend/Manager can render them in
-            distinct sections. ``source`` is the same string as the
-            ``module_parent`` used at load time (e.g. ``"custom_nodes"``,
-            ``"comfy_extras"``, ``"comfy_api_nodes"``) and is left as a
-            free-form string so the contract survives node-source layouts
-            evolving. The response only contains source buckets that actually
-            had a failure; consumers should not assume any particular set of
-            keys is always present.
-
-            ``module_path`` is stripped because the absolute on-disk path is
-            internal detail that the frontend has no use for.
-            """
-            grouped: dict[str, dict[str, dict]] = {}
-            for entry in nodes.NODE_STARTUP_ERRORS.values():
-                source = entry.get("source", "custom_nodes")
-                public_entry = {k: v for k, v in entry.items() if k != "module_path"}
-                grouped.setdefault(source, {})[entry["module_name"]] = public_entry
-            return web.json_response(grouped)
-
         @routes.get("/api/jobs")
         async def get_jobs(request):
             """List all jobs with filtering, sorting, and pagination.

tests-unit/node_startup_errors_test.py

@@ -1,146 +0,0 @@
-"""Tests for the custom node startup error tracking introduced for
-Comfy-Org/ComfyUI-Launcher#303.
-
-Covers:
-- load_custom_node populates NODE_STARTUP_ERRORS with the correct source
-  for each module_parent (custom_nodes / comfy_extras / comfy_api_nodes).
-- Composite keying prevents collisions between modules with the same name
-  in different sources.
-- record_node_startup_error stores the expected fields.
-- pyproject.toml metadata is attached when present and omitted when absent.
-"""
-import textwrap
-
-import pytest
-
-import nodes
-
-
-@pytest.fixture(autouse=True)
-def _clear_startup_errors():
-    nodes.NODE_STARTUP_ERRORS.clear()
-    yield
-    nodes.NODE_STARTUP_ERRORS.clear()
-
-
-def _write_broken_module(tmp_path, name: str) -> str:
-    path = tmp_path / f"{name}.py"
-    path.write_text(textwrap.dedent("""\
-        # Deliberately broken module to exercise startup-error tracking.
-        raise RuntimeError("boom from " + __name__)
-    """))
-    return str(path)
-
-
-def test_record_node_startup_error_fields(tmp_path):
-    err = ValueError("kaboom")
-    nodes.record_node_startup_error(
-        module_path=str(tmp_path / "my_pack"),
-        source="custom_nodes",
-        phase="import",
-        error=err,
-        tb="traceback-text",
-    )
-    assert "custom_nodes:my_pack" in nodes.NODE_STARTUP_ERRORS
-    entry = nodes.NODE_STARTUP_ERRORS["custom_nodes:my_pack"]
-    assert entry["source"] == "custom_nodes"
-    assert entry["module_name"] == "my_pack"
-    assert entry["phase"] == "import"
-    assert entry["error"] == "kaboom"
-    assert entry["traceback"] == "traceback-text"
-    assert entry["module_path"].endswith("my_pack")
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "module_parent",
-    ["custom_nodes", "comfy_extras", "comfy_api_nodes"],
-)
-async def test_load_custom_node_records_source(tmp_path, module_parent):
-    # `source` in the entry should be the same string as `module_parent`.
-    module_path = _write_broken_module(tmp_path, "broken_pack")
-
-    success = await nodes.load_custom_node(module_path, module_parent=module_parent)
-    assert success is False
-
-    key = f"{module_parent}:broken_pack"
-    assert key in nodes.NODE_STARTUP_ERRORS, nodes.NODE_STARTUP_ERRORS
-    entry = nodes.NODE_STARTUP_ERRORS[key]
-    assert entry["source"] == module_parent
-    assert entry["module_name"] == "broken_pack"
-    assert entry["phase"] == "import"
-    assert "boom from" in entry["error"]
-    assert "RuntimeError" in entry["traceback"]
-
-
-@pytest.mark.asyncio
-async def test_load_custom_node_collision_across_sources(tmp_path):
-    # Same module name registered as both a custom node and a comfy_extra;
-    # composite keying should keep both entries.
-    cn_dir = tmp_path / "cn"
-    extras_dir = tmp_path / "extras"
-    cn_dir.mkdir()
-    extras_dir.mkdir()
-    cn_path = _write_broken_module(cn_dir, "nodes_audio")
-    extras_path = _write_broken_module(extras_dir, "nodes_audio")
-
-    assert await nodes.load_custom_node(cn_path, module_parent="custom_nodes") is False
-    assert await nodes.load_custom_node(extras_path, module_parent="comfy_extras") is False
-
-    assert "custom_nodes:nodes_audio" in nodes.NODE_STARTUP_ERRORS
-    assert "comfy_extras:nodes_audio" in nodes.NODE_STARTUP_ERRORS
-    assert (
-        nodes.NODE_STARTUP_ERRORS["custom_nodes:nodes_audio"]["module_path"]
-        != nodes.NODE_STARTUP_ERRORS["comfy_extras:nodes_audio"]["module_path"]
-    )
-
-
-@pytest.mark.asyncio
-async def test_load_custom_node_attaches_pyproject_metadata(tmp_path):
-    pack_dir = tmp_path / "MyCoolPack"
-    pack_dir.mkdir()
-    (pack_dir / "__init__.py").write_text("raise RuntimeError('boom')\n")
-    (pack_dir / "pyproject.toml").write_text(textwrap.dedent("""\
-        [project]
-        name = "comfyui-mycoolpack"
-        version = "1.2.3"
-
-        [project.urls]
-        Repository = "https://github.com/example/comfyui-mycoolpack"
-
-        [tool.comfy]
-        PublisherId = "example"
-        DisplayName = "My Cool Pack"
-    """))
-
-    success = await nodes.load_custom_node(str(pack_dir), module_parent="custom_nodes")
-    assert success is False
-
-    entry = nodes.NODE_STARTUP_ERRORS["custom_nodes:MyCoolPack"]
-    assert "pyproject" in entry, entry
-    py = entry["pyproject"]
-    assert py["pack_id"] == "comfyui-mycoolpack"
-    assert py["display_name"] == "My Cool Pack"
-    assert py["publisher_id"] == "example"
-    assert py["version"] == "1.2.3"
-    assert py["repository"] == "https://github.com/example/comfyui-mycoolpack"
-
-
-@pytest.mark.asyncio
-async def test_load_custom_node_no_pyproject_skips_metadata(tmp_path):
-    # Single-file extras-style module: no pyproject.toml exists alongside it,
-    # so the entry must not contain a 'pyproject' key.
-    module_path = _write_broken_module(tmp_path, "lonely")
-    assert await nodes.load_custom_node(module_path, module_parent="comfy_extras") is False
-    entry = nodes.NODE_STARTUP_ERRORS["comfy_extras:lonely"]
-    assert "pyproject" not in entry
-
-
-@pytest.mark.asyncio
-async def test_load_custom_node_arbitrary_module_parent_passes_through(tmp_path):
-    # `source` is a free-form string — an unknown module_parent (e.g. a future
-    # node-source bucket) should be recorded as-is, not coerced or rejected.
-    module_path = _write_broken_module(tmp_path, "future_pack")
-    assert await nodes.load_custom_node(module_path, module_parent="future_source") is False
-    entry = nodes.NODE_STARTUP_ERRORS["future_source:future_pack"]
-    assert entry["source"] == "future_source"