The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
feat(assets): include asset id in executed WebSocket message (#13862)
Matt Millerce200c085018
diff --git a/comfy_execution/asset_enrichment.py b/comfy_execution/asset_enrichment.pynew file mode 100644index 000000000..38e9496a8--- /dev/null+++ b/comfy_execution/asset_enrichment.py@@ -0,0 +1,66 @@+"""Enrich executed-node output entries with asset id."""+import logging+import os+++def enrich_output_with_assets(output_ui: dict) -> dict:+ """Register file-type output entries as assets and inject their ``id``.++ Runs at output-processing time, once per produced output, when+ --enable-assets is set. Returns a new dict; entries without a resolvable+ on-disk file path are left unchanged. Errors are caught per-entry so a+ failure never blocks execution or the other entries.+ """+ from comfy.cli_args import args+ if not args.enable_assets:+ return output_ui++ import folder_paths+ from app.assets.services.ingest import register_file_in_place, DependencyMissingError++ enriched = {}+ for key, entries in output_ui.items():+ if not isinstance(entries, list):+ enriched[key] = entries+ continue+ new_entries = []+ for entry in entries:+ if not isinstance(entry, dict) or "filename" not in entry or "type" not in entry:+ new_entries.append(entry)+ continue+ try:+ base = folder_paths.get_directory_by_type(entry["type"])+ if base is None:+ new_entries.append(entry)+ continue+ base_abs = os.path.abspath(base)+ abs_path = os.path.abspath(os.path.join(base_abs, entry.get("subfolder") or "", entry["filename"]))+ try:+ if os.path.commonpath([base_abs, abs_path]) != base_abs:+ raise ValueError("escapes base")+ except ValueError:+ logging.warning("Asset enrichment skipped (path escapes base): %s", entry.get("filename"))+ new_entries.append(entry)+ continue+ if not os.path.isfile(abs_path):+ new_entries.append(entry)+ continue++ # Register unconditionally: the file was just produced, and+ # register_file_in_place re-hashes so an overwritten path can+ # never carry a stale id.+ result = register_file_in_place(+ abs_path=abs_path,+ name=entry["filename"],+ tags=[entry["type"]],+ )++ entry = dict(entry)+ entry["id"] = result.ref.id+ except DependencyMissingError:+ logging.warning("Asset enrichment skipped (blake3 not available): %s", entry.get("filename"))+ except Exception:+ logging.warning("Failed to enrich output entry with asset id: %s", entry.get("filename"), exc_info=True)+ new_entries.append(entry)+ enriched[key] = new_entries+ return enricheddiff --git a/execution.py b/execution.pyindex 5246d651c..e6c6f39d6 100644--- a/execution.py+++ b/execution.py@@ -40,6 +40,7 @@ from comfy_execution.graph_utils import GraphBuilder, is_linkfrom comfy_execution.validation import validate_node_inputfrom comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandlerfrom comfy_execution.utils import CurrentNodeContext+from comfy_execution.asset_enrichment import enrich_output_with_assetsfrom comfy_api.internal import _ComfyNodeInternal, _NodeOutputInternal, first_real_override, is_class, make_locked_method_funcfrom comfy_api.latest import io, _iofrom comfy_execution.cache_provider import _has_cache_providers, _get_cache_providers, _logger as _cache_logger@@ -418,6 +419,7 @@ def _is_intermediate_output(dynprompt, node_id):class_def = nodes.NODE_CLASS_MAPPINGS[class_type]return getattr(class_def, 'HAS_INTERMEDIATE_OUTPUT', False)+def _send_cached_ui(server, node_id, display_node_id, cached, prompt_id, ui_outputs):if server.client_id is None:return@@ -552,6 +554,10 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,asyncio.create_task(await_completion())return (ExecutionResult.PENDING, None, None)if len(output_ui) > 0:+ # Enrich at output-processing time (not in the send path) so assets+ # are registered even when no client is connected, and the asset id+ # flows into ui_outputs and the cache alongside the raw entries.+ output_ui = enrich_output_with_assets(output_ui)ui_outputs[unique_id] = {"meta": {"node_id": unique_id,diff --git a/tests-unit/execution_test/test_enrich_output.py b/tests-unit/execution_test/test_enrich_output.pynew file mode 100644index 000000000..61490c49e--- /dev/null+++ b/tests-unit/execution_test/test_enrich_output.py@@ -0,0 +1,205 @@+"""Tests for enrich_output_with_assets in comfy_execution/asset_enrichment.py."""+import os+import types+import unittest+from unittest.mock import MagicMock, patch+++def _make_args(enable_assets: bool):+ a = types.SimpleNamespace()+ a.enable_assets = enable_assets+ return a+++def _make_register_result(ref_id="ref-id-2"):+ result = MagicMock()+ result.ref.id = ref_id+ return result+++# Platform-appropriate absolute base. tempfile.gettempdir() returns C:\... on+# Windows and /tmp on POSIX, so containment via commonpath behaves naturally.+_DEFAULT_BASE = os.path.join(__import__("tempfile").gettempdir(), "asset-enrichment-test-base")+++def _mocked_modules(*, enable_assets=True, register_file_in_place=None, directory=_DEFAULT_BASE):+ return {+ "comfy.cli_args": MagicMock(args=_make_args(enable_assets)),+ "folder_paths": MagicMock(get_directory_by_type=MagicMock(return_value=directory)),+ "app.assets.services.ingest": MagicMock(+ register_file_in_place=register_file_in_place or MagicMock(return_value=_make_register_result()),+ DependencyMissingError=type("DependencyMissingError", (Exception,), {}),+ ),+ }+++def _call(output_ui, *, enable_assets=True, file_exists=True, register_result=None, directory=_DEFAULT_BASE):+ register_mock = MagicMock(return_value=register_result or _make_register_result())+ mocked = _mocked_modules(+ enable_assets=enable_assets,+ register_file_in_place=register_mock,+ directory=directory,+ )++ # Only os.path.isfile is patched — abspath/join must run natively so the+ # containment check sees real platform paths.+ with patch.dict("sys.modules", mocked), \+ patch("os.path.isfile", return_value=file_exists):+ import importlib+ import comfy_execution.asset_enrichment as mod+ importlib.reload(mod)+ return mod.enrich_output_with_assets(output_ui)+++class TestEnrichOutputWithAssets(unittest.TestCase):++ def test_disabled_returns_unchanged(self):+ output = {"images": [{"filename": "a.png", "subfolder": "", "type": "output"}]}+ result = _call(output, enable_assets=False)+ self.assertNotIn("id", result["images"][0])++ def test_non_list_value_passed_through(self):+ output = {"text": "hello"}+ result = _call(output)+ self.assertEqual(result["text"], "hello")++ def test_entry_without_filename_unchanged(self):+ output = {"latent": [{"subfolder": "", "type": "output"}]}+ result = _call(output)+ self.assertNotIn("id", result["latent"][0])++ def test_entry_without_type_unchanged(self):+ output = {"data": [{"filename": "a.png", "subfolder": ""}]}+ result = _call(output)+ self.assertNotIn("id", result["data"][0])++ def test_file_not_on_disk_unchanged(self):+ output = {"images": [{"filename": "missing.png", "subfolder": "", "type": "output"}]}+ result = _call(output, file_exists=False)+ self.assertNotIn("id", result["images"][0])++ def test_unknown_type_returns_none_directory_unchanged(self):+ output = {"images": [{"filename": "a.png", "subfolder": "", "type": "unknown"}]}+ result = _call(output, directory=None)+ self.assertNotIn("id", result["images"][0])++ def test_register_injects_only_id(self):+ reg = _make_register_result(ref_id="inline-ref")+ output = {"images": [{"filename": "new.png", "subfolder": "", "type": "output"}]}+ result = _call(output, register_result=reg)+ img = result["images"][0]+ self.assertEqual(img["id"], "inline-ref")+ # Only id is injected — no asset_hash, name, preview_url, size+ self.assertNotIn("asset_hash", img)+ self.assertNotIn("name", img)+ self.assertNotIn("preview_url", img)+ self.assertNotIn("size", img)++ def test_register_called_per_entry(self):+ register_mock = MagicMock(return_value=_make_register_result())+ mocked = _mocked_modules(register_file_in_place=register_mock)+ output = {+ "images": [+ {"filename": "a.png", "subfolder": "", "type": "output"},+ {"filename": "b.png", "subfolder": "", "type": "output"},+ ]+ }++ with patch.dict("sys.modules", mocked), \+ patch("os.path.isfile", return_value=True):+ import importlib+ import comfy_execution.asset_enrichment as mod+ importlib.reload(mod)+ mod.enrich_output_with_assets(output)++ self.assertEqual(register_mock.call_count, 2)++ def test_original_entry_not_mutated(self):+ orig = {"filename": "a.png", "subfolder": "", "type": "output"}+ output = {"images": [orig]}+ _call(output)+ self.assertNotIn("id", orig)++ def test_enrichment_error_does_not_block_sibling_entries(self):+ call_count = [0]+ good_reg = _make_register_result(ref_id="good-ref")++ def register_side_effect(abs_path, name, tags):+ call_count[0] += 1+ if call_count[0] == 1:+ raise RuntimeError("boom")+ return good_reg++ mocked = _mocked_modules(register_file_in_place=register_side_effect)++ output = {+ "images": [+ {"filename": "bad.png", "subfolder": "", "type": "output"},+ {"filename": "good.png", "subfolder": "", "type": "output"},+ ]+ }++ with patch.dict("sys.modules", mocked), \+ patch("os.path.isfile", return_value=True):+ import importlib+ import comfy_execution.asset_enrichment as mod+ importlib.reload(mod)+ result = mod.enrich_output_with_assets(output)++ imgs = result["images"]+ self.assertNotIn("id", imgs[0])+ self.assertEqual(imgs[1]["id"], "good-ref")++ def test_multiple_output_keys_all_enriched(self):+ output = {+ "images": [{"filename": "a.png", "subfolder": "", "type": "output"}],+ "videos": [{"filename": "b.mp4", "subfolder": "", "type": "output"}],+ }+ result = _call(output)+ self.assertIn("id", result["images"][0])+ self.assertIn("id", result["videos"][0])++ def test_none_entry_in_list_unchanged(self):+ output = {"images": [None, {"filename": "a.png", "subfolder": "", "type": "output"}]}+ result = _call(output)+ self.assertIsNone(result["images"][0])+ self.assertIn("id", result["images"][1])++ def test_path_traversal_subfolder_skipped(self):+ register_mock = MagicMock(return_value=_make_register_result())+ mocked = _mocked_modules(register_file_in_place=register_mock)++ output = {"images": [{"filename": "passwd", "subfolder": "../../etc", "type": "output"}]}++ # Do NOT patch os.path.abspath — real resolution is required for the containment check.+ with patch.dict("sys.modules", mocked), \+ patch("os.path.isfile", return_value=True):+ import importlib+ import comfy_execution.asset_enrichment as mod+ importlib.reload(mod)+ result = mod.enrich_output_with_assets(output)++ self.assertNotIn("id", result["images"][0])+ register_mock.assert_not_called()++ def test_absolute_filename_skipped(self):+ register_mock = MagicMock(return_value=_make_register_result())+ mocked = _mocked_modules(register_file_in_place=register_mock)++ # Absolute filename — os.path.join discards earlier components when a later one is absolute.+ absolute_filename = os.path.abspath(os.sep + "etc" + os.sep + "passwd")+ output = {"images": [{"filename": absolute_filename, "subfolder": "", "type": "output"}]}++ with patch.dict("sys.modules", mocked), \+ patch("os.path.isfile", return_value=True):+ import importlib+ import comfy_execution.asset_enrichment as mod+ importlib.reload(mod)+ result = mod.enrich_output_with_assets(output)++ self.assertNotIn("id", result["images"][0])+ register_mock.assert_not_called()+++if __name__ == "__main__":+ unittest.main()