comfy-env 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

comfy_env/isolation/wrap.py

@@ -145,15 +145,19 @@ def _find_env_paths(node_dir: Path) -> tuple[Optional[Path], Optional[Path]]:
     """
     Find site-packages and lib directories for the isolated environment.
 
+    Fallback order:
+        1. Marker file -> central cache
+        2. _env_<name> (local)
+        3. .pixi/envs/default (old pixi)
+        4. .venv
+
     Returns:
         (site_packages, lib_dir) - lib_dir is for LD_LIBRARY_PATH
     """
     import glob
 
-    # Check _env_<name> directory first (new pattern)
-    env_name = get_env_name(node_dir.name)
-    env_dir = node_dir / env_name
-    if env_dir.exists():
+    def _get_paths_from_env(env_dir: Path) -> tuple[Optional[Path], Optional[Path]]:
+        """Extract site-packages and lib_dir from an env directory."""
         if sys.platform == "win32":
             site_packages = env_dir / "Lib" / "site-packages"
             lib_dir = env_dir / "Library" / "bin"
@@ -163,23 +167,42 @@ def _find_env_paths(node_dir: Path) -> tuple[Optional[Path], Optional[Path]]:
             site_packages = Path(matches[0]) if matches else None
             lib_dir = env_dir / "lib"
         if site_packages and site_packages.exists():
-            return site_packages, lib_dir if lib_dir.exists() else None
+            return site_packages, lib_dir if lib_dir and lib_dir.exists() else None
+        return None, None
 
-    # Fallback: Check old .pixi/envs/default (for backward compat)
+    # 1. Check marker file -> central cache
+    marker_path = node_dir / ".comfy-env-marker.toml"
+    if marker_path.exists():
+        try:
+            import tomli
+            with open(marker_path, "rb") as f:
+                marker = tomli.load(f)
+            env_path = marker.get("env", {}).get("path")
+            if env_path:
+                env_dir = Path(env_path)
+                if env_dir.exists():
+                    result = _get_paths_from_env(env_dir)
+                    if result[0]:
+                        return result
+        except Exception:
+            pass  # Fall through to other options
+
+    # 2. Check _env_<name> directory (local)
+    env_name = get_env_name(node_dir.name)
+    env_dir = node_dir / env_name
+    if env_dir.exists():
+        result = _get_paths_from_env(env_dir)
+        if result[0]:
+            return result
+
+    # 3. Fallback: Check old .pixi/envs/default (for backward compat)
     pixi_env = node_dir / ".pixi" / "envs" / "default"
     if pixi_env.exists():
-        if sys.platform == "win32":
-            site_packages = pixi_env / "Lib" / "site-packages"
-            lib_dir = pixi_env / "Library" / "bin"
-        else:
-            pattern = str(pixi_env / "lib" / "python*" / "site-packages")
-            matches = glob.glob(pattern)
-            site_packages = Path(matches[0]) if matches else None
-            lib_dir = pixi_env / "lib"
-        if site_packages and site_packages.exists():
-            return site_packages, lib_dir if lib_dir.exists() else None
+        result = _get_paths_from_env(pixi_env)
+        if result[0]:
+            return result
 
-    # Check .venv directory
+    # 4. Check .venv directory
     venv_dir = node_dir / ".venv"
     if venv_dir.exists():
         if sys.platform == "win32":
@@ -195,19 +218,46 @@ def _find_env_paths(node_dir: Path) -> tuple[Optional[Path], Optional[Path]]:
 
 
 def _find_env_dir(node_dir: Path) -> Optional[Path]:
-    """Find the environment directory (for cache key)."""
-    # Check _env_<name> first
+    """
+    Find the environment directory (for cache key).
+
+    Fallback order:
+        1. Marker file -> central cache
+        2. _env_<name> (local)
+        3. .pixi/envs/default (old pixi)
+        4. .venv
+    """
+    # 1. Check marker file -> central cache
+    marker_path = node_dir / ".comfy-env-marker.toml"
+    if marker_path.exists():
+        try:
+            import tomli
+            with open(marker_path, "rb") as f:
+                marker = tomli.load(f)
+            env_path = marker.get("env", {}).get("path")
+            if env_path:
+                env_dir = Path(env_path)
+                if env_dir.exists():
+                    return env_dir
+        except Exception:
+            pass
+
+    # 2. Check _env_<name> first
     env_name = get_env_name(node_dir.name)
     env_dir = node_dir / env_name
     if env_dir.exists():
         return env_dir
-    # Fallback to old paths
+
+    # 3. Fallback to old .pixi path
     pixi_env = node_dir / ".pixi" / "envs" / "default"
     if pixi_env.exists():
         return pixi_env
+
+    # 4. Check .venv
     venv_dir = node_dir / ".venv"
     if venv_dir.exists():
         return venv_dir
+
     return None
 
 
@@ -335,6 +385,131 @@ def _wrap_node_class(
     return cls
 
 
+def _is_comfy_env_enabled() -> bool:
+    """Check if comfy-env isolation is enabled (default: True)."""
+    val = os.environ.get("USE_COMFY_ENV", "1").lower()
+    return val not in ("0", "false", "no", "off")
+
+
+def wrap_nodes() -> None:
+    """
+    Auto-wrap nodes for isolation. Call from your __init__.py after defining NODE_CLASS_MAPPINGS.
+
+    Usage:
+        from comfy_env import wrap_nodes
+        wrap_nodes()
+    """
+    # Skip if isolation is disabled
+    if not _is_comfy_env_enabled():
+        print(f"[comfy-env] Isolation disabled, nodes running in main process")
+        return
+
+    # Skip if running inside worker subprocess
+    if os.environ.get("COMFYUI_ISOLATION_WORKER") == "1":
+        return
+
+    # Get caller's frame and module
+    frame = inspect.stack()[1]
+    caller_module = inspect.getmodule(frame.frame)
+    if caller_module is None:
+        print("[comfy-env] Warning: Could not determine caller module")
+        return
+
+    # Get NODE_CLASS_MAPPINGS from caller's module
+    node_class_mappings = getattr(caller_module, "NODE_CLASS_MAPPINGS", None)
+    if not node_class_mappings:
+        print("[comfy-env] Warning: No NODE_CLASS_MAPPINGS found in caller module")
+        return
+
+    # Get package root directory
+    caller_file = Path(frame.filename).resolve()
+    package_dir = caller_file.parent
+
+    # Find all comfy-env.toml files
+    config_files = list(package_dir.rglob("comfy-env.toml"))
+    if not config_files:
+        return  # No configs, nothing to wrap
+
+    # Get ComfyUI base path
+    try:
+        import folder_paths
+        comfyui_base = folder_paths.base_path
+    except ImportError:
+        comfyui_base = None
+
+    # Build a map of config_dir -> env info
+    config_envs = []
+    for config_file in config_files:
+        config_dir = config_file.parent
+        env_dir = _find_env_dir(config_dir)
+        site_packages, lib_dir = _find_env_paths(config_dir)
+
+        if not env_dir or not site_packages:
+            continue
+
+        # Read env_vars from config
+        env_vars = {}
+        try:
+            import tomli
+            with open(config_file, "rb") as f:
+                config = tomli.load(f)
+            env_vars_data = config.get("env_vars", {})
+            env_vars = {str(k): str(v) for k, v in env_vars_data.items()}
+        except Exception:
+            pass
+
+        if comfyui_base:
+            env_vars["COMFYUI_BASE"] = str(comfyui_base)
+
+        config_envs.append({
+            "config_dir": config_dir,
+            "env_dir": env_dir,
+            "site_packages": site_packages,
+            "lib_dir": lib_dir,
+            "env_vars": env_vars,
+        })
+
+    if not config_envs:
+        return
+
+    # Match nodes to configs by checking source file location
+    wrapped_count = 0
+    for node_name, node_cls in node_class_mappings.items():
+        if not hasattr(node_cls, "FUNCTION"):
+            continue
+
+        # Get node's source file
+        try:
+            source_file = Path(inspect.getfile(node_cls)).resolve()
+        except (TypeError, OSError):
+            continue
+
+        # Find which config this node belongs to
+        for env_info in config_envs:
+            config_dir = env_info["config_dir"]
+            try:
+                source_file.relative_to(config_dir)
+                # Node is under this config dir - wrap it
+                sys_path = [str(env_info["site_packages"]), str(config_dir)]
+                lib_path = str(env_info["lib_dir"]) if env_info["lib_dir"] else None
+
+                _wrap_node_class(
+                    node_cls,
+                    env_info["env_dir"],
+                    config_dir,
+                    sys_path,
+                    lib_path,
+                    env_info["env_vars"],
+                )
+                wrapped_count += 1
+                break
+            except ValueError:
+                continue  # Node not under this config dir
+
+    if wrapped_count > 0:
+        print(f"[comfy-env] Wrapped {wrapped_count} nodes for isolation")
+
+
 def wrap_isolated_nodes(
     node_class_mappings: Dict[str, type],
     nodes_dir: Path,
@@ -369,6 +544,11 @@ def wrap_isolated_nodes(
             wrap_isolated_nodes(cgal_nodes, Path(__file__).parent / "nodes/cgal")
         )
     """
+    # Skip if isolation is disabled
+    if not _is_comfy_env_enabled():
+        print(f"[comfy-env] Isolation disabled, nodes running in main process")
+        return node_class_mappings
+
     # Skip if running inside worker subprocess
     if os.environ.get("COMFYUI_ISOLATION_WORKER") == "1":
         return node_class_mappings
@@ -391,12 +571,9 @@ def wrap_isolated_nodes(
     # Read env_vars from comfy-env.toml
     env_vars = {}
     try:
-        if sys.version_info >= (3, 11):
-            import tomllib
-        else:
-            import tomli as tomllib
+        import tomli
         with open(config_file, "rb") as f:
-            config = tomllib.load(f)
+            config = tomli.load(f)
         env_vars_data = config.get("env_vars", {})
         env_vars = {str(k): str(v) for k, v in env_vars_data.items()}
     except Exception:

comfy_env/nodes.py

@@ -17,7 +17,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Callable, List, Set
 
 if TYPE_CHECKING:
-    from .config.types import NodeReq
+    from .config.parser import NodeReq
 
 
 def normalize_repo_url(repo: str) -> str:

comfy_env/pixi/core.py

@@ -18,7 +18,7 @@ import urllib.request
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
-from ..config.types import ComfyEnvConfig
+from ..config.parser import ComfyEnvConfig
 
 
 # Pixi download URLs by platform
@@ -37,7 +37,6 @@ CUDA_WHEELS_INDEX = "https://pozzettiandrea.github.io/cuda-wheels/"
 CUDA_TORCH_MAP = {
     "12.8": "2.8",
     "12.4": "2.4",
-    "12.1": "2.4",
 }
 
 def find_wheel_url(
@@ -534,20 +533,55 @@ def pixi_install(
 
         log("CUDA packages installed")
 
-    # Move environment from .pixi/envs/default to _env_<name>
+    # Move environment from .pixi/envs/default to central cache
+    from ..cache import (
+        get_central_env_path, write_marker, write_env_metadata,
+        MARKER_FILE, get_cache_dir
+    )
+
     old_env = node_dir / ".pixi" / "envs" / "default"
-    env_name = get_env_name(node_dir.name)
-    new_env = node_dir / env_name
+    config_path = node_dir / "comfy-env.toml"
+
+    # Determine the main node directory (for naming)
+    # If node_dir is custom_nodes/NodeName/subdir, main_node_dir is custom_nodes/NodeName
+    # If node_dir is custom_nodes/NodeName, main_node_dir is custom_nodes/NodeName
+    if node_dir.parent.name == "custom_nodes":
+        main_node_dir = node_dir
+    else:
+        # Walk up to find custom_nodes parent
+        main_node_dir = node_dir
+        for parent in node_dir.parents:
+            if parent.parent.name == "custom_nodes":
+                main_node_dir = parent
+                break
+
+    # Get central env path
+    central_env = get_central_env_path(main_node_dir, config_path)
 
     if old_env.exists():
-        if new_env.exists():
-            shutil.rmtree(new_env)  # Clean old env
-        shutil.move(str(old_env), str(new_env))
-        # Clean up .pixi directory (keep pixi.toml and pixi.lock)
+        # Ensure cache directory exists
+        get_cache_dir()
+
+        # Remove old central env if exists
+        if central_env.exists():
+            shutil.rmtree(central_env)
+
+        # Move to central cache
+        shutil.move(str(old_env), str(central_env))
+
+        # Write marker file in node directory
+        write_marker(config_path, central_env)
+
+        # Write metadata in env for orphan detection
+        marker_path = config_path.parent / MARKER_FILE
+        write_env_metadata(central_env, marker_path)
+
+        # Clean up .pixi directory
         pixi_dir = node_dir / ".pixi"
         if pixi_dir.exists():
             shutil.rmtree(pixi_dir)
-        log(f"Moved environment to {new_env}")
+
+        log(f"Environment created at: {central_env}")
 
     log("Installation complete!")
     return True

comfy_env/prestartup.py

@@ -20,24 +20,16 @@ def get_env_name(dir_name: str) -> str:
 def _load_env_vars(config_path: str) -> Dict[str, str]:
     """
     Load [env_vars] section from comfy-env.toml.
-
-    Uses tomllib (Python 3.11+) or tomli fallback.
     Returns empty dict if file not found or parsing fails.
     """
     if not os.path.exists(config_path):
         return {}
 
     try:
-        if sys.version_info >= (3, 11):
-            import tomllib
-        else:
-            try:
-                import tomli as tomllib
-            except ImportError:
-                return {}
+        import tomli
 
         with open(config_path, "rb") as f:
-            data = tomllib.load(f)
+            data = tomli.load(f)
 
         env_vars_data = data.get("env_vars", {})
         return {str(k): str(v) for k, v in env_vars_data.items()}
@@ -95,6 +87,12 @@ def _dedupe_libomp_macos():
                 pass  # Permission denied, etc.
 
 
+def _is_comfy_env_enabled() -> bool:
+    """Check if comfy-env isolation is enabled (default: True)."""
+    val = os.environ.get("USE_COMFY_ENV", "1").lower()
+    return val not in ("0", "false", "no", "off")
+
+
 def setup_env(node_dir: Optional[str] = None) -> None:
     """
     Set up environment for pixi conda libraries.
@@ -112,6 +110,10 @@ def setup_env(node_dir: Optional[str] = None) -> None:
         from comfy_env import setup_env
         setup_env()
     """
+    # Skip if isolation is disabled
+    if not _is_comfy_env_enabled():
+        return
+
     # macOS: Dedupe libomp to prevent OpenMP conflicts (torch vs pymeshlab, etc.)
     _dedupe_libomp_macos()
 
@@ -127,15 +129,40 @@ def setup_env(node_dir: Optional[str] = None) -> None:
     for key, value in env_vars.items():
         os.environ[key] = value
 
-    # Check _env_<name> first, then fallback to old .pixi path
-    env_name = get_env_name(os.path.basename(node_dir))
-    pixi_env = os.path.join(node_dir, env_name)
-
-    if not os.path.exists(pixi_env):
-        # Fallback to old .pixi path
-        pixi_env = os.path.join(node_dir, ".pixi", "envs", "default")
-        if not os.path.exists(pixi_env):
-            return  # No environment found
+    # Resolve environment path with fallback chain:
+    # 1. Marker file -> central cache
+    # 2. _env_<name> (current local)
+    # 3. .pixi/envs/default (old pixi)
+    pixi_env = None
+
+    # 1. Check marker file -> central cache
+    marker_path = os.path.join(node_dir, ".comfy-env-marker.toml")
+    if os.path.exists(marker_path):
+        try:
+            import tomli
+            with open(marker_path, "rb") as f:
+                marker = tomli.load(f)
+            env_path = marker.get("env", {}).get("path")
+            if env_path and os.path.exists(env_path):
+                pixi_env = env_path
+        except Exception:
+            pass  # Fall through to other options
+
+    # 2. Check _env_<name> (local)
+    if not pixi_env:
+        env_name = get_env_name(os.path.basename(node_dir))
+        local_env = os.path.join(node_dir, env_name)
+        if os.path.exists(local_env):
+            pixi_env = local_env
+
+    # 3. Fallback to old .pixi path
+    if not pixi_env:
+        old_pixi = os.path.join(node_dir, ".pixi", "envs", "default")
+        if os.path.exists(old_pixi):
+            pixi_env = old_pixi
+
+    if not pixi_env:
+        return  # No environment found
 
     if sys.platform == "win32":
         # Windows: add to PATH for DLL loading
@@ -162,3 +189,20 @@ def setup_env(node_dir: Optional[str] = None) -> None:
 
     if site_packages and os.path.exists(site_packages) and site_packages not in sys.path:
         sys.path.insert(0, site_packages)
+
+
+def copy_files(src, dst, pattern: str = "*") -> None:
+    """Copy files matching pattern from src to dst (skip existing)."""
+    import shutil
+
+    src, dst = Path(src), Path(dst)
+    if not src.exists():
+        return
+
+    dst.mkdir(parents=True, exist_ok=True)
+    for f in src.glob(pattern):
+        if f.is_file():
+            target = dst / f.relative_to(src)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            if not target.exists():
+                shutil.copy2(f, target)

comfy_env/workers/subprocess.py

@@ -440,7 +440,7 @@ def _watchdog():
             f.flush()
 
         # Also print
-        print(f"\\n=== WATCHDOG TICK {tick} ===", flush=True)
+        print(f"\\n=== WATCHDOG TICK {tick} (debug only, don't worry) ===", flush=True)
         print(dump, flush=True)
         print("=== END ===\\n", flush=True)
 

{comfy_env-0.1.13.dist-info → comfy_env-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.13
+Version: 0.1.15
 Summary: Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation
 Project-URL: Homepage, https://github.com/PozzettiAndrea/comfy-env
 Project-URL: Repository, https://github.com/PozzettiAndrea/comfy-env
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: pip>=21.0
 Requires-Dist: tomli-w>=1.0.0
-Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: tomli>=2.0.0
 Requires-Dist: uv>=0.4.0
 Provides-Extra: dev
 Requires-Dist: mypy; extra == 'dev'

comfy_env-0.1.15.dist-info/RECORD

@@ -0,0 +1,31 @@
+comfy_env/__init__.py,sha256=vtMEMhys8esoSXM3H5pFJGecE_ZoDwPS0foeEzlbmZA,2331
+comfy_env/cache.py,sha256=LnOVGCheF0hM-JZcX_-HD46o_nA7U2SIptdOT1TQkBE,6293
+comfy_env/cli.py,sha256=UJbPbCEKfAAoZ_J0JeUs4jVsWuJ8BeR6CV6XtCSuy1g,12707
+comfy_env/install.py,sha256=nuG3z5V1PQ4IoXKknLfS9sUKAUq0RHcpZp7jvdOTgIY,14853
+comfy_env/nodes.py,sha256=tqMBf3hTjtgbT9sdcUiNnMaiFNPsHWtw79_TgvsrU9Q,5392
+comfy_env/prestartup.py,sha256=Aw8yvmkraP3bRXPTZKOFnhUHLNtGujAZ4aD76nKx6pA,7215
+comfy_env/config/__init__.py,sha256=_udIO2AkntkFfktst1uKqRkLdne1cXf2b0BrErvNT_k,289
+comfy_env/config/parser.py,sha256=B9iK3RQdErAHnmvD_jfZm87u5K5gTnEwFDMdOXil3YM,3458
+comfy_env/isolation/__init__.py,sha256=Fy8A7_5plxcCMFOf00cJlEMbRVu8aKFkTo0Spj31YqI,206
+comfy_env/isolation/wrap.py,sha256=vJz75TtS6NMyfxX_UlqNdZNQQYROHP9KbcghmNIPyFM,20046
+comfy_env/pixi/__init__.py,sha256=BUrq7AQf3WDm0cHWh72B2xZbURNnDu2dCuELWiQCUiM,997
+comfy_env/pixi/core.py,sha256=LY2wrvMNqO-cp9MOgixvpe1mJKtGK3U311-0rbURTBo,21770
+comfy_env/pixi/cuda_detection.py,sha256=sqB3LjvGNdV4eFqiARQGfyecBM3ZiUmeh6nG0YCRYQw,9751
+comfy_env/pixi/resolver.py,sha256=U_A8rBDxCj4gUlJt2YJQniP4cCKqxJEiVFgXOoH7vM8,6339
+comfy_env/pixi/platform/__init__.py,sha256=Nb5MPZIEeanSMEWwqU4p4bnEKTJn1tWcwobnhq9x9IY,614
+comfy_env/pixi/platform/base.py,sha256=iS0ptTTVjXRwPU4qWUdvHI7jteuzxGSjWr5BUQ7hGiU,2453
+comfy_env/pixi/platform/darwin.py,sha256=HK3VkLT6DfesAnIXwx2IaUFHTBclF0xTQnC7azWY6Kc,1552
+comfy_env/pixi/platform/linux.py,sha256=xLp8FEbFqZLQrzIZBI9z3C4g23Ab1ASTHLsXDzsdCoA,2062
+comfy_env/pixi/platform/windows.py,sha256=FCOCgpzGzorY9-HueMlJUR8DxM2eH-cj9iZk6K026Is,10891
+comfy_env/templates/comfy-env-instructions.txt,sha256=ve1RAthW7ouumU9h6DM7mIRX1MS8_Tyonq2U4tcrFu8,1031
+comfy_env/templates/comfy-env.toml,sha256=ROIqi4BlPL1MEdL1VgebfTHpdwPNYGHwWeigI9Kw-1I,4831
+comfy_env/workers/__init__.py,sha256=TMVG55d2XLP1mJ3x1d16H0SBDJZtk2kMC5P4HLk9TrA,1073
+comfy_env/workers/base.py,sha256=4ZYTaQ4J0kBHCoO_OfZnsowm4rJCoqinZUaOtgkOPbw,2307
+comfy_env/workers/mp.py,sha256=R0XWsiHv8gswxa_-iNHU14o_9Og0RFG0QnY9DRZzn2c,34060
+comfy_env/workers/subprocess.py,sha256=FvhEWilFWkjYNVDm7mmbFmXiSYB7eT5Tl2uvJ_23qnc,57154
+comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
+comfy_env-0.1.15.dist-info/METADATA,sha256=HMJQ4qs9ObD6YpTGffqmUACR67_kzcWv392WpdNASzc,6946
+comfy_env-0.1.15.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.1.15.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.1.15.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.1.15.dist-info/RECORD,,

comfy_env/config/types.py

@@ -1,70 +0,0 @@
-"""Configuration types for comfy-env."""
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-
-@dataclass
-class NodeReq:
-    """A node dependency (another ComfyUI custom node)."""
-    name: str
-    repo: str  # GitHub repo, e.g., "owner/repo"
-
-
-@dataclass
-class ComfyEnvConfig:
-    """
-    Configuration from comfy-env.toml.
-
-    comfy-env.toml is a superset of pixi.toml. Custom sections we handle:
-    - python = "3.11" - Python version for isolated envs
-    - [cuda] packages = [...] - CUDA packages (triggers find-links + PyTorch detection)
-    - [node_reqs] - Other ComfyUI nodes to clone
-
-    Everything else passes through to pixi.toml directly:
-    - [dependencies] - conda packages
-    - [pypi-dependencies] - pip packages
-    - [target.linux-64.pypi-dependencies] - platform-specific deps
-    - Any other pixi.toml syntax
-
-    Example config:
-        python = "3.11"
-
-        [cuda]
-        packages = ["cumesh"]
-
-        [dependencies]
-        mesalib = "*"
-        cgal = "*"
-
-        [pypi-dependencies]
-        numpy = ">=1.21.0,<2"
-        trimesh = { version = ">=4.0.0", extras = ["easy"] }
-
-        [target.linux-64.pypi-dependencies]
-        embreex = "*"
-
-        [node_reqs]
-        SomeNode = "owner/repo"
-    """
-    # python = "3.11" - Python version (for isolated envs)
-    python: Optional[str] = None
-
-    # [cuda] - CUDA packages (installed via find-links index)
-    cuda_packages: List[str] = field(default_factory=list)
-
-    # [apt] - System packages to install via apt (Linux only)
-    apt_packages: List[str] = field(default_factory=list)
-
-    # [env_vars] - Environment variables to set early (in prestartup)
-    env_vars: Dict[str, str] = field(default_factory=dict)
-
-    # [node_reqs] - other ComfyUI nodes to clone
-    node_reqs: List[NodeReq] = field(default_factory=list)
-
-    # Everything else from comfy-env.toml passes through to pixi.toml
-    pixi_passthrough: Dict[str, Any] = field(default_factory=dict)
-
-    @property
-    def has_cuda(self) -> bool:
-        return bool(self.cuda_packages)