global dumping_traceback

if dumping_traceback:

raise KeyboardInterrupt

dumping_traceback = True

faulthandler.dump_traceback(file=sys.stderr, all_threads=True)

manager_req_path = os.path.join(os.path.dirname(os.path.abspath(folder_paths.__file__)), "manager_requirements.txt")

uv_available = shutil.which("uv") is not None

pip_cmd = f"{sys.executable} -m pip install -r {manager_req_path}"

msg = f"\n\nTo use the `--enable-manager` feature, the `comfyui-manager` package must be installed first.\ncommand:\n\t{pip_cmd}"

if uv_available:

msg += f"\nor using uv:\n\tuv pip install -r {manager_req_path}"

msg += "\n"

logging.warning(msg)

# extra model paths

extra_model_paths_config_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "extra_model_paths.yaml")

if os.path.isfile(extra_model_paths_config_path):

utils.extra_config.load_extra_path_config(extra_model_paths_config_path)

if args.extra_model_paths_config:

for config_path in itertools.chain(*args.extra_model_paths_config):

utils.extra_config.load_extra_path_config(config_path)

# --base-directory

if args.base_directory:

logging.info(f"Setting base directory to: {folder_paths.base_path}")

# --models-directory

if args.models_directory:

logging.info(f"Setting models directory to: {folder_paths.models_dir}")

# --output-directory, --input-directory, --user-directory

if args.output_directory:

output_dir = os.path.abspath(args.output_directory)

logging.info(f"Setting output directory to: {output_dir}")

folder_paths.set_output_directory(output_dir)

# These are the default folders that checkpoints, clip and vae models will be saved to when using CheckpointSave, etc.. nodes

folder_paths.add_model_folder_path("checkpoints", os.path.join(folder_paths.get_output_directory(), "checkpoints"))

folder_paths.add_model_folder_path("clip", os.path.join(folder_paths.get_output_directory(), "clip"))

folder_paths.add_model_folder_path("vae", os.path.join(folder_paths.get_output_directory(), "vae"))

folder_paths.add_model_folder_path("diffusion_models",

os.path.join(folder_paths.get_output_directory(), "diffusion_models"))

folder_paths.add_model_folder_path("loras", os.path.join(folder_paths.get_output_directory(), "loras"))

if args.input_directory:

input_dir = os.path.abspath(args.input_directory)

logging.info(f"Setting input directory to: {input_dir}")

folder_paths.set_input_directory(input_dir)

if args.user_directory:

user_dir = os.path.abspath(args.user_directory)

logging.info(f"Setting user directory to: {user_dir}")

if args.disable_all_custom_nodes and len(args.whitelist_custom_nodes) == 0:

return

def execute_script(script_path):

module_name = os.path.splitext(script_path)[0]

try:

spec = importlib.util.spec_from_file_location(module_name, script_path)

module = importlib.util.module_from_spec(spec)

spec.loader.exec_module(module)

return True

except Exception as e:

logging.error(f"Failed to execute startup-script: {script_path} / {e}")

return False

node_paths = folder_paths.get_folder_paths("custom_nodes")

node_prestartup_times = []

for custom_node_path in node_paths:

possible_modules = os.listdir(custom_node_path)

for possible_module in possible_modules:

module_path = os.path.join(custom_node_path, possible_module)

if args.enable_manager:

if comfyui_manager.should_be_disabled(module_path):

continue

if os.path.isfile(module_path) or module_path.endswith(".disabled") or module_path == "__pycache__":

continue

script_path = os.path.join(module_path, "prestartup_script.py")

if os.path.exists(script_path):

if args.disable_all_custom_nodes and possible_module not in args.whitelist_custom_nodes:

logging.info(f"Prestartup Skipping {possible_module} due to disable_all_custom_nodes and whitelist_custom_nodes")

continue

time_before = time.perf_counter()

success = execute_script(script_path)

node_prestartup_times.append((time.perf_counter() - time_before, module_path, success))

if len(node_prestartup_times) > 0:

logging.info("\nPrestartup times for custom nodes:")

for n in sorted(node_prestartup_times):

if n[2]:

import_message = ""

else:

import_message = " (PRESTARTUP FAILED)"

logging.info("{:6.1f} seconds{}: {}".format(n[0], import_message, n[1]))

if comfy.model_management.is_nvidia():

return True

if comfy.model_management.is_amd():

if comfy.model_management.rocm_version >= (7, 14):

return True

device = comfy.model_management.get_torch_device()

device_name = comfy.model_management.get_torch_device_name(device)

cuda_malloc_warning = False

if "cudaMallocAsync" in device_name:

for b in cuda_malloc.blacklist:

if b in device_name:

cuda_malloc_warning = True

if cuda_malloc_warning:

current_time: float = 0.0

cache_ram = 0

cache_ram_inactive = 0

if not args.cache_classic and not args.cache_none and args.cache_lru <= 0:

cache_ram = min(10.0, max(2.0, comfy.model_management.total_ram * 0.10 / 1024.0))

cache_ram_inactive = min(128.0, comfy.model_management.total_ram / 1024.0)

if len(args.cache_ram) > 0:

cache_ram = args.cache_ram[0]

if len(args.cache_ram) > 1:

cache_ram_inactive = args.cache_ram[1]

cache_type = execution.CacheType.RAM_PRESSURE

if args.cache_classic:

cache_type = execution.CacheType.CLASSIC

elif args.cache_lru > 0:

cache_type = execution.CacheType.LRU

elif args.cache_none:

cache_type = execution.CacheType.NONE

e = execution.PromptExecutor(server_instance, cache_type=cache_type, cache_args={ "lru" : args.cache_lru, "ram" : cache_ram, "ram_inactive" : cache_ram_inactive }, asset_manager=asset_manager )

last_gc_collect = 0

need_gc = False

gc_collect_interval = 10.0

background_scan_paused = False

while True:

try:

timeout = 1000.0

if need_gc:

timeout = max(gc_collect_interval - (current_time - last_gc_collect), 0.0)

queue_item = q.get(timeout=timeout)

if queue_item is not None:

item, item_id = queue_item

execution_start_time = time.perf_counter()

prompt_id = item[1]

server_instance.last_prompt_id = prompt_id

sensitive = item[5]

extra_data = item[3].copy()

for k in sensitive:

extra_data[k] = sensitive[k]

asset_manager.pause_background_scan()

background_scan_paused = True

e.execute(item[2], prompt_id, extra_data, item[4])

need_gc = True

remove_sensitive = lambda prompt: prompt[:5] + prompt[6:]

q.task_done(item_id,

e.history_result,

status=execution.PromptQueue.ExecutionStatus(

status_str='success' if e.success else 'error',

completed=e.success,

messages=e.status_messages), process_item=remove_sensitive)

if server_instance.client_id is not None:

server_instance.send_sync("executing", {"node": None, "prompt_id": prompt_id}, server_instance.client_id)

current_time = time.perf_counter()

execution_time = current_time - execution_start_time

# Log Time in a more readable way after 10 minutes

if execution_time > 600:

execution_time = time.strftime("%H:%M:%S", time.gmtime(execution_time))

logging.info(f"Prompt executed in {execution_time}", extra={'color': 'green'})

else:

logging.info("Prompt executed in {:.2f} seconds".format(execution_time), extra={'color': 'green'})

flags = q.get_flags()

free_memory = flags.get("free_memory", False)

if flags.get("unload_models", free_memory):

comfy.model_management.unload_all_models()

need_gc = True

last_gc_collect = 0

if free_memory:

e.reset()

need_gc = True

last_gc_collect = 0

if need_gc:

current_time = time.perf_counter()

if (current_time - last_gc_collect) > gc_collect_interval:

gc.collect()

comfy.model_management.soft_empty_cache()

last_gc_collect = current_time

need_gc = False

hook_breaker_ac10a0.restore_functions()

asset_manager.queue_output_scan()

asset_manager.resume_background_scan()

background_scan_paused = False

# BaseException is deliberate. This runs on the worker thread, so Ctrl-C lands in

# the main thread instead, and resume only flips the seeder's pause state.

except BaseException:

if background_scan_paused:

try:

asset_manager.resume_background_scan()

except Exception:

logging.exception("Failed to resume background asset scanning after prompt worker failure")

addresses = []

for addr in address.split(","):

addresses.append((addr, port))

await asyncio.gather(

server_instance.start_multi_address(addresses, call_on_start, verbose), server_instance.publish_loop()

def hook(value, total, preview_image, prompt_id=None, node_id=None):

executing_context = get_executing_context()

if prompt_id is None and executing_context is not None:

prompt_id = executing_context.prompt_id

if node_id is None and executing_context is not None:

node_id = executing_context.node_id

comfy.model_management.throw_exception_if_processing_interrupted()

if prompt_id is None:

prompt_id = server_instance.last_prompt_id

if node_id is None:

node_id = server_instance.last_node_id

progress = {"value": value, "max": total, "prompt_id": prompt_id, "node": node_id}

get_progress_state().update_progress(node_id, value, total, preview_image)

server_instance.send_sync("progress", progress, server_instance.client_id)

if preview_image is not None:

# Only send old method if client doesn't support preview metadata

if not feature_flags.supports_feature(

server_instance.sockets_metadata,

server_instance.client_id,

"supports_preview_metadata",

):

server_instance.send_sync(

BinaryEventTypes.UNENCODED_PREVIEW_IMAGE,

preview_image,

server_instance.client_id,

)

if not dependencies_available():

return

try:

init_db()

asset_manager.startup()

except Exception as e:

if "database is locked" in str(e):

logging.error(

"Database is locked. Another ComfyUI process is already using this database.\n"

"To resolve this, specify a separate database file for this instance:\n"

" --database-url sqlite:///path/to/another.db"

)

sys.exit(1)

if "Could not acquire lock on database" in str(e):

logging.error(

"Database is locked. Another ComfyUI process is already using this database.\n"

"To resolve this, specify a separate database file for this instance:\n"

" --database-url sqlite:///path/to/another.db"

)

if args.enable_assets:

sys.exit(1)

return

if args.enable_assets:

logging.error(

f"Failed to initialize database: {e}\n"

"The --enable-assets flag requires a working database connection.\n"

"To resolve this, try one of the following:\n"

" 1. Install the latest requirements: pip install -r requirements.txt\n"

" 2. Specify an alternative database URL: --database-url sqlite:///path/to/your.db\n"

" 3. Use an in-memory database: --database-url sqlite:///:memory:"

)

sys.exit(1)

"""

if args.temp_directory:

temp_dir = os.path.join(os.path.abspath(args.temp_directory), "temp")

logging.info(f"Setting temp directory to: {temp_dir}")

folder_paths.set_temp_directory(temp_dir)

asset_manager: AssetManager = default_asset_manager()

feature_flags.SERVER_FEATURE_FLAGS["assets"] = asset_manager.enabled

if not asset_manager.enabled:

cleanup_temp_filesystem()

if not asyncio_loop:

asyncio_loop = asyncio.new_event_loop()

asyncio.set_event_loop(asyncio_loop)

prompt_server = server.PromptServer(asyncio_loop, asset_manager)

if args.enable_manager and not args.disable_manager_ui:

comfyui_manager.start()

hook_breaker_ac10a0.save_functions()

asyncio_loop.run_until_complete(nodes.init_extra_nodes(

init_custom_nodes=(not args.disable_all_custom_nodes) or len(args.whitelist_custom_nodes) > 0,

init_api_nodes=not args.disable_api_nodes

))

# Re-apply Comfy's cuDNN benchmark policy after custom-node imports. Benchmark

# mode can request near-card-sized autotune workspaces, and some custom nodes set it at import time.

comfy.model_management.set_cudnn_benchmark()

hook_breaker_ac10a0.restore_functions()

cuda_malloc_warning()

setup_database(asset_manager)

prompt_server.add_routes()

hijack_progress(prompt_server)

threading.Thread(target=prompt_worker, daemon=True, args=(prompt_server.prompt_queue, prompt_server, asset_manager)).start()

if args.quick_test_for_ci:

exit(0)

os.makedirs(folder_paths.get_temp_directory(), exist_ok=True)

call_on_start = None

if args.auto_launch:

def startup_server(scheme, address, port):

import webbrowser

if os.name == 'nt' and address == '0.0.0.0':

address = '127.0.0.1'

if ':' in address:

address = "[{}]".format(address)

webbrowser.open(f"{scheme}://{address}:{port}")

call_on_start = startup_server

async def start_all():

await prompt_server.setup()

await run(prompt_server, address=args.listen, port=args.port, verbose=not args.dont_print_server, call_on_start=call_on_start)

# Returning these so that other code can integrate with the ComfyUI loop and server