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

comfy_env-0.1.16.dist-info/METADATA

@@ -0,0 +1,279 @@
+Metadata-Version: 2.4
+Name: comfy-env
+Version: 0.1.16
+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
+Project-URL: Issues, https://github.com/PozzettiAndrea/comfy-env/issues
+Author: Andrea Pozzetti
+License: MIT
+License-File: LICENSE
+Keywords: comfyui,cuda,environment,isolation,process,venv,wheels
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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
+Requires-Dist: uv>=0.4.0
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# comfy-env
+
+Environment management for ComfyUI custom nodes.
+
+## Quick Start
+
+```bash
+pip install comfy-env
+```
+
+**1. Create `comfy-env.toml` in your node directory:**
+
+```toml
+[cuda]
+packages = ["nvdiffrast", "pytorch3d"]
+
+[pypi-dependencies]
+trimesh = { version = "*", extras = ["easy"] }
+```
+
+**2. In `install.py`:**
+
+```python
+from comfy_env import install
+install()
+```
+
+**3. In `prestartup_script.py`:**
+
+```python
+from comfy_env import setup_env
+setup_env()
+```
+
+That's it. CUDA wheels install without compilation, and the environment is ready.
+
+---
+
+## Configuration
+
+Create `comfy-env.toml` in your node directory:
+
+```toml
+# Python version for isolated environment (optional)
+python = "3.11"
+
+# CUDA packages from cuda-wheels index (no compilation needed)
+[cuda]
+packages = ["nvdiffrast", "pytorch3d", "flash-attn"]
+
+# System packages (Linux only)
+[apt]
+packages = ["libgl1-mesa-glx", "libglu1-mesa"]
+
+# Environment variables
+[env_vars]
+KMP_DUPLICATE_LIB_OK = "TRUE"
+OMP_NUM_THREADS = "1"
+
+# Dependent custom nodes to auto-install
+[node_reqs]
+ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+
+# Conda packages (via pixi)
+[dependencies]
+cgal = "*"
+
+# PyPI packages
+[pypi-dependencies]
+trimesh = { version = "*", extras = ["easy"] }
+numpy = "*"
+```
+
+---
+
+## Process Isolation
+
+For nodes with conflicting dependencies, use isolated execution:
+
+```python
+# In nodes/__init__.py
+from pathlib import Path
+from comfy_env import wrap_isolated_nodes
+
+# Import your isolated nodes
+from .cgal import NODE_CLASS_MAPPINGS as cgal_mappings
+
+# Wrap them for isolated execution
+NODE_CLASS_MAPPINGS = wrap_isolated_nodes(
+    cgal_mappings,
+    Path(__file__).parent / "cgal"  # Directory with comfy-env.toml
+)
+```
+
+Each wrapped node runs in a subprocess with its own Python environment.
+
+---
+
+## CLI Commands
+
+```bash
+# Show detected environment
+comfy-env info
+
+# Install dependencies
+comfy-env install
+
+# Preview without installing
+comfy-env install --dry-run
+
+# Verify packages
+comfy-env doctor
+
+# Install system packages
+comfy-env apt-install
+```
+
+---
+
+## API Reference
+
+### install()
+
+Install dependencies from comfy-env.toml:
+
+```python
+from comfy_env import install
+
+install()                    # Auto-detect config
+install(dry_run=True)        # Preview only
+install(config="path.toml")  # Explicit config
+```
+
+### setup_env()
+
+Set up environment at ComfyUI startup:
+
+```python
+from comfy_env import setup_env
+
+setup_env()  # Auto-detects node directory from caller
+```
+
+Sets library paths, environment variables, and injects site-packages.
+
+### wrap_isolated_nodes()
+
+Wrap nodes for subprocess isolation:
+
+```python
+from comfy_env import wrap_isolated_nodes
+
+wrapped = wrap_isolated_nodes(NODE_CLASS_MAPPINGS, node_dir)
+```
+
+### Detection
+
+```python
+from comfy_env import (
+    detect_cuda_version,      # Returns "12.8", "12.4", or None
+    detect_gpu,               # Returns GPUInfo or None
+    get_gpu_summary,          # Human-readable string
+    RuntimeEnv,               # Combined runtime info
+)
+
+env = RuntimeEnv.detect()
+print(env)  # Python 3.11, CUDA 12.8, PyTorch 2.8.0, GPU: RTX 4090
+```
+
+### Workers
+
+Low-level process isolation:
+
+```python
+from comfy_env import MPWorker, SubprocessWorker
+
+# Same Python version (multiprocessing)
+worker = MPWorker()
+result = worker.call(my_function, arg1, arg2)
+
+# Different Python version (subprocess)
+worker = SubprocessWorker(python="/path/to/python")
+result = worker.call(my_function, arg1, arg2)
+```
+
+---
+
+## Real Example
+
+See [ComfyUI-GeometryPack](https://github.com/PozzettiAndrea/ComfyUI-GeometryPack) for a production example with:
+
+- Multiple isolated environments (CGAL, Blender, GPU)
+- Per-subdirectory comfy-env.toml
+- Prestartup asset copying
+- Different Python versions (3.11 for Blender API)
+
+---
+
+## Architecture
+
+### Layers
+
+```
+comfy_env/
+├── detection/     # Pure functions - CUDA, GPU, platform detection
+├── config/        # Pure parsing - comfy-env.toml → typed config
+├── environment/   # Side effects - cache, paths, setup
+├── packages/      # Side effects - pixi, cuda-wheels, apt
+├── isolation/     # Side effects - subprocess workers, node wrapping
+└── install.py     # Orchestration
+```
+
+### Why Isolation?
+
+ComfyUI nodes share a single Python environment. This breaks when:
+
+1. **Dependency conflicts**: Node A needs `torch==2.4`, Node B needs `torch==2.8`
+2. **Native library conflicts**: Two packages bundle incompatible libomp
+3. **Python version requirements**: Blender API requires Python 3.11
+
+Solution: Run each node group in its own subprocess with isolated dependencies.
+
+### Why CUDA Wheels?
+
+Installing packages like `nvdiffrast` normally requires:
+- CUDA toolkit
+- C++ compiler
+- 30+ minutes of compilation
+
+CUDA wheels from [cuda-wheels](https://pozzettiandrea.github.io/cuda-wheels/) are pre-built for common configurations:
+
+| GPU | CUDA | PyTorch |
+|-----|------|---------|
+| Blackwell (sm_100+) | 12.8 | 2.8 |
+| Ada/Hopper/Ampere | 12.8 | 2.8 |
+| Turing | 12.8 | 2.8 |
+| Pascal | 12.4 | 2.4 |
+
+### How Environments Work
+
+1. **Central cache**: Environments stored at `~/.comfy-env/envs/`
+2. **Marker files**: `.comfy-env-marker.toml` links node → env
+3. **Orphan cleanup**: Envs deleted when their node is removed
+4. **Hash-based naming**: Config changes create new envs
+
+---
+
+## License
+
+MIT

comfy_env-0.1.16.dist-info/RECORD

@@ -0,0 +1,36 @@
+comfy_env/__init__.py,sha256=uoHq-m1274tOeinWsIpW81MkRQilHx9z8_coJSqH9qc,4641
+comfy_env/cli.py,sha256=abdUBItk8OkzxKBu7cKRPizO5_i5DFflvx7pYpPc7OM,6696
+comfy_env/install.py,sha256=BV8OfY3Rt-BiKFzpDNHfs4mfLYalbsiIMNU-y9CmLDg,10467
+comfy_env/config/__init__.py,sha256=noqhycE0UF4ZntV5NnWcFApppQludQDHvJOtLsQgUIo,542
+comfy_env/config/parser.py,sha256=79C8LIwCO4920MU7CJ08hfMWh-5Ehzr-i5XQna5K81A,1951
+comfy_env/config/types.py,sha256=vFgWeEl_p26OmcoUv0wAOlHe9GBio2isjIWl7kACKFY,1096
+comfy_env/detection/__init__.py,sha256=dH84PlSRJfs8MRJp2gp9_NX8ZzGIDHR8iZXy7_B8Ez4,1671
+comfy_env/detection/cuda.py,sha256=BOaRQOGP2yoaPCO9eqPvWBB5Us_MNo-sSbadQsIjHqM,1708
+comfy_env/detection/gpu.py,sha256=Rf7pgtZXzUbJqcXzZXQi-yK5naeuSP1FiL6SdreeADM,8393
+comfy_env/detection/platform.py,sha256=Xe01dIZm7JT19kIH-j11h7KIBVRaKTLh8u4TzI3uZ6E,2127
+comfy_env/detection/runtime.py,sha256=gDplni7ZPGW7WjNJuqWbtgSwkWz27kBWSFvYbhXun6o,3756
+comfy_env/environment/__init__.py,sha256=WfZnyOvbI0MrDQPYTtOG2kHn0XCSCrqKcOlJcmB29nU,1009
+comfy_env/environment/cache.py,sha256=RGfVW2caMO0Dd1nX2otUQP0xW3pVS7iSOP4vIUAMdEA,4568
+comfy_env/environment/libomp.py,sha256=nzr3kDnRLgcf9CZ_WF4ItWskqEDS2S0geqZS43XoKig,1319
+comfy_env/environment/paths.py,sha256=5TFFAkOZXa8R3cHfVHDEFnwy6_JcHilVBOHJuy-yqR0,1129
+comfy_env/environment/setup.py,sha256=34To-cJX85sZ5W33dxcNosedrrICNUzVzqBcJkq4FLI,3013
+comfy_env/isolation/__init__.py,sha256=XfMLEiBIcEzHG_k2vk9fT9GvFfmOsfbpM26czuxbdRI,800
+comfy_env/isolation/tensor_utils.py,sha256=2_f4jjylqCPaPldD1Jw-es5CyOtuF5I1ROdyEIxsg-U,2951
+comfy_env/isolation/wrap.py,sha256=K7GAkqU_Uxe717eUtPsFv5kcr_Jfbh3x79A-8vbY1nY,8592
+comfy_env/isolation/workers/__init__.py,sha256=Zp6sZSRBcb5Negqgzqs3jPjfO9T1u3nNrQhp6WqTAuc,325
+comfy_env/isolation/workers/base.py,sha256=4ZYTaQ4J0kBHCoO_OfZnsowm4rJCoqinZUaOtgkOPbw,2307
+comfy_env/isolation/workers/mp.py,sha256=ygOgx2iyLN7l5fWkKI4lqzQsDyfAAd9Gb4gTYLp7o1A,34061
+comfy_env/isolation/workers/subprocess.py,sha256=ML6I9IenReagP8iT0Cd2ipet6JPK1gnDbOianOuFwOw,57164
+comfy_env/packages/__init__.py,sha256=6PTwUfUdJDTbIw46dCiA42qk4zUe_gw29xOaklBiMMc,1193
+comfy_env/packages/apt.py,sha256=pxy3A5ZHv3X8ExCVyohODY8Fcy9ji4izIVPfYoxhqT4,1027
+comfy_env/packages/cuda_wheels.py,sha256=G_CnlwNcfeWlEU24aCVBpeqQQ05y8_02dDLBwBFNwII,3980
+comfy_env/packages/node_dependencies.py,sha256=AX_CY6j43tTY5KhyPfU7Wz6zgLAfWF0o0JkTrcNSecg,2966
+comfy_env/packages/pixi.py,sha256=RPu8x5sSOLE1CYAhWMMjoQrbFGGt00fdsbqtRcTz7LQ,3871
+comfy_env/packages/toml_generator.py,sha256=Vhc8F9euHhMTwH1TV6t96-D9Pjrn9jIN4e9WXrCIFE8,3414
+comfy_env/templates/comfy-env-instructions.txt,sha256=ve1RAthW7ouumU9h6DM7mIRX1MS8_Tyonq2U4tcrFu8,1031
+comfy_env/templates/comfy-env.toml,sha256=ROIqi4BlPL1MEdL1VgebfTHpdwPNYGHwWeigI9Kw-1I,4831
+comfy_env-0.1.16.dist-info/METADATA,sha256=SLbnLOFz5AbqS8YT9-TWslRzo4QghO2EwUtQwn2B0OE,6468
+comfy_env-0.1.16.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.1.16.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.1.16.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.1.16.dist-info/RECORD,,

comfy_env/cache.py

@@ -1,203 +0,0 @@
-"""Central environment cache management."""
-
-import hashlib
-import os
-import shutil
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Optional, Tuple, Callable
-
-# Import version
-try:
-    from . import __version__
-except ImportError:
-    __version__ = "0.0.0-dev"
-
-import tomli
-import tomli_w
-
-
-# Constants
-CACHE_DIR = Path.home() / ".comfy-env" / "envs"
-MARKER_FILE = ".comfy-env-marker.toml"
-METADATA_FILE = ".comfy-env-metadata.toml"
-
-
-def get_cache_dir() -> Path:
-    """Get central cache directory, create if needed."""
-    CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    return CACHE_DIR
-
-
-def compute_config_hash(config_path: Path) -> str:
-    """Compute hash of comfy-env.toml content (first 8 chars of SHA256)."""
-    content = config_path.read_bytes()
-    return hashlib.sha256(content).hexdigest()[:8]
-
-
-def sanitize_name(name: str) -> str:
-    """Sanitize a name for use in filesystem paths."""
-    # Lowercase and replace problematic chars
-    name = name.lower()
-    for prefix in ("comfyui-", "comfyui_"):
-        if name.startswith(prefix):
-            name = name[len(prefix):]
-    return name.replace("-", "_").replace(" ", "_")
-
-
-def get_env_name(node_dir: Path, config_path: Path) -> str:
-    """Generate env name: <nodename>_<subfolder>_<hash>."""
-    # Get node name
-    node_name = sanitize_name(node_dir.name)
-
-    # Get subfolder (relative path from node_dir to config parent)
-    config_parent = config_path.parent
-    if config_parent == node_dir:
-        subfolder = ""
-    else:
-        try:
-            rel_path = config_parent.relative_to(node_dir)
-            subfolder = rel_path.as_posix().replace("/", "_")
-        except ValueError:
-            # config_path not under node_dir - use parent folder name
-            subfolder = sanitize_name(config_parent.name)
-
-    # Compute hash
-    config_hash = compute_config_hash(config_path)
-
-    return f"{node_name}_{subfolder}_{config_hash}"
-
-
-def get_central_env_path(node_dir: Path, config_path: Path) -> Path:
-    """Get path to central environment for this config."""
-    env_name = get_env_name(node_dir, config_path)
-    return get_cache_dir() / env_name
-
-
-def write_marker(config_path: Path, env_path: Path) -> None:
-    """Write marker file linking node to central env."""
-    marker_path = config_path.parent / MARKER_FILE
-    marker_data = {
-        "env": {
-            "name": env_path.name,
-            "path": str(env_path),
-            "config_hash": compute_config_hash(config_path),
-            "created": datetime.now().isoformat(),
-            "comfy_env_version": __version__,
-        }
-    }
-    marker_path.write_text(tomli_w.dumps(marker_data))
-
-
-def write_env_metadata(env_path: Path, marker_path: Path) -> None:
-    """Write metadata file for orphan detection."""
-    metadata_path = env_path / METADATA_FILE
-    metadata = {
-        "marker_path": str(marker_path),
-        "created": datetime.now().isoformat(),
-    }
-    metadata_path.write_text(tomli_w.dumps(metadata))
-
-
-def read_marker(marker_path: Path) -> Optional[dict]:
-    """Read marker file, return None if invalid/missing."""
-    if not marker_path.exists():
-        return None
-    try:
-        with open(marker_path, "rb") as f:
-            return tomli.load(f)
-    except Exception:
-        return None
-
-
-def read_env_metadata(env_path: Path) -> Optional[dict]:
-    """Read metadata file from env, return None if invalid/missing."""
-    metadata_path = env_path / METADATA_FILE
-    if not metadata_path.exists():
-        return None
-    try:
-        with open(metadata_path, "rb") as f:
-            return tomli.load(f)
-    except Exception:
-        return None
-
-
-def resolve_env_path(node_dir: Path) -> Tuple[Optional[Path], Optional[Path], Optional[Path]]:
-    """Resolve environment path. Returns (env_path, site_packages, lib_dir)."""
-    # 1. Check marker file -> central cache
-    marker_path = node_dir / MARKER_FILE
-    marker = read_marker(marker_path)
-    if marker and "env" in marker:
-        env_path = Path(marker["env"]["path"])
-        if env_path.exists():
-            return _get_env_paths(env_path)
-
-    # 2. Check _env_<name>
-    node_name = sanitize_name(node_dir.name)
-    env_name = f"_env_{node_name}"
-    local_env = node_dir / env_name
-    if local_env.exists():
-        return _get_env_paths(local_env)
-
-    # 3. Check .pixi/envs/default
-    pixi_env = node_dir / ".pixi" / "envs" / "default"
-    if pixi_env.exists():
-        return _get_env_paths(pixi_env)
-
-    # 4. Check .venv
-    venv_dir = node_dir / ".venv"
-    if venv_dir.exists():
-        return _get_env_paths(venv_dir)
-
-    return None, None, None
-
-
-def _get_env_paths(env_path: Path) -> Tuple[Path, Optional[Path], Optional[Path]]:
-    """Get site-packages and lib paths from an environment."""
-    import glob
-
-    if sys.platform == "win32":
-        site_packages = env_path / "Lib" / "site-packages"
-        lib_dir = env_path / "Library" / "bin"
-    else:
-        # Linux/Mac: lib/python*/site-packages
-        matches = glob.glob(str(env_path / "lib" / "python*" / "site-packages"))
-        site_packages = Path(matches[0]) if matches else None
-        lib_dir = env_path / "lib"
-
-    return env_path, site_packages, lib_dir
-
-
-def cleanup_orphaned_envs(log: Callable[[str], None] = print) -> int:
-    """Remove orphaned environments. Returns count cleaned."""
-    cache_dir = get_cache_dir()
-    if not cache_dir.exists():
-        return 0
-
-    cleaned = 0
-    for env_dir in cache_dir.iterdir():
-        if not env_dir.is_dir():
-            continue
-
-        # Skip if no metadata (might be manually created or old format)
-        metadata = read_env_metadata(env_dir)
-        if not metadata:
-            continue
-
-        # Check if marker file still exists
-        marker_path_str = metadata.get("marker_path", "")
-        if not marker_path_str:
-            continue
-
-        marker_path = Path(marker_path_str)
-        if not marker_path.exists():
-            # Marker gone = node was deleted = orphan
-            log(f"[comfy-env] Cleaning orphaned env: {env_dir.name}")
-            try:
-                shutil.rmtree(env_dir)
-                cleaned += 1
-            except Exception as e:
-                log(f"[comfy-env] Failed to cleanup {env_dir.name}: {e}")
-
-    return cleaned

comfy_env/nodes.py

@@ -1,187 +0,0 @@
-"""
-Node dependency installation for comfy-env.
-
-This module handles installation of dependent ComfyUI custom nodes
-specified in the [node_reqs] section of comfy-env.toml.
-
-Example configuration:
-    [node_reqs]
-    ComfyUI_essentials = "cubiq/ComfyUI_essentials"
-    ComfyUI-DepthAnythingV2 = "kijai/ComfyUI-DepthAnythingV2"
-"""
-
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from typing import TYPE_CHECKING, Callable, List, Set
-
-if TYPE_CHECKING:
-    from .config.parser import NodeReq
-
-
-def normalize_repo_url(repo: str) -> str:
-    """
-    Convert GitHub shorthand to full URL.
-
-    Args:
-        repo: Either 'owner/repo' or full URL like 'https://github.com/owner/repo'
-
-    Returns:
-        Full GitHub URL
-    """
-    if repo.startswith("http://") or repo.startswith("https://"):
-        return repo
-    return f"https://github.com/{repo}"
-
-
-def clone_node(
-    repo: str,
-    name: str,
-    target_dir: Path,
-    log: Callable[[str], None],
-) -> Path:
-    """
-    Clone a node repository to target_dir/name.
-
-    Args:
-        repo: GitHub repo path (e.g., 'owner/repo') or full URL
-        name: Directory name for the cloned repo
-        target_dir: Parent directory (usually custom_nodes/)
-        log: Logging callback
-
-    Returns:
-        Path to the cloned node directory
-
-    Raises:
-        RuntimeError: If git clone fails
-    """
-    node_path = target_dir / name
-    url = normalize_repo_url(repo)
-
-    log(f"  Cloning {name} from {url}...")
-    result = subprocess.run(
-        ["git", "clone", "--depth", "1", url, str(node_path)],
-        capture_output=True,
-        text=True,
-    )
-
-    if result.returncode != 0:
-        raise RuntimeError(f"Failed to clone {url}: {result.stderr.strip()}")
-
-    return node_path
-
-
-def install_requirements(
-    node_dir: Path,
-    log: Callable[[str], None],
-) -> None:
-    """
-    Install requirements.txt in a node directory if it exists.
-
-    Args:
-        node_dir: Path to the node directory
-        log: Logging callback
-    """
-    requirements_file = node_dir / "requirements.txt"
-
-    if not requirements_file.exists():
-        return
-
-    log(f"  Installing requirements for {node_dir.name}...")
-
-    # Try uv first, fall back to pip if uv not in PATH
-    if shutil.which("uv"):
-        cmd = ["uv", "pip", "install", "-r", str(requirements_file), "--python", sys.executable]
-    else:
-        cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
-
-    result = subprocess.run(cmd, cwd=node_dir, capture_output=True, text=True)
-    if result.returncode != 0:
-        log(f"  Warning: requirements.txt install failed for {node_dir.name}: {result.stderr.strip()[:200]}")
-
-
-def run_install_script(
-    node_dir: Path,
-    log: Callable[[str], None],
-) -> None:
-    """
-    Run install.py in a node directory if it exists.
-
-    Args:
-        node_dir: Path to the node directory
-        log: Logging callback
-    """
-    install_script = node_dir / "install.py"
-
-    if install_script.exists():
-        log(f"  Running install.py for {node_dir.name}...")
-        result = subprocess.run(
-            [sys.executable, str(install_script)],
-            cwd=node_dir,
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode != 0:
-            log(f"  Warning: install.py failed for {node_dir.name}: {result.stderr.strip()[:200]}")
-
-
-def install_node_deps(
-    node_reqs: "List[NodeReq]",
-    custom_nodes_dir: Path,
-    log: Callable[[str], None],
-    visited: Set[str],
-) -> None:
-    """
-    Install node dependencies recursively.
-
-    Args:
-        node_reqs: List of NodeReq objects to install
-        custom_nodes_dir: Path to custom_nodes directory
-        log: Logging callback
-        visited: Set of already-processed node names (for cycle detection)
-    """
-    from .config.parser import discover_config
-
-    for req in node_reqs:
-        # Skip if already visited (cycle detection)
-        if req.name in visited:
-            log(f"  {req.name}: already in dependency chain, skipping")
-            continue
-
-        visited.add(req.name)
-
-        node_path = custom_nodes_dir / req.name
-
-        # Skip if already installed (directory exists)
-        if node_path.exists():
-            log(f"  {req.name}: already installed, skipping")
-            continue
-
-        try:
-            # Clone the repository
-            clone_node(req.repo, req.name, custom_nodes_dir, log)
-
-            # Install requirements.txt if present
-            install_requirements(node_path, log)
-
-            # Run install.py if present
-            run_install_script(node_path, log)
-
-            # Recursively process nested node_reqs
-            try:
-                nested_config = discover_config(node_path)
-                if nested_config and nested_config.node_reqs:
-                    log(f"  {req.name}: found {len(nested_config.node_reqs)} nested dependencies")
-                    install_node_deps(
-                        nested_config.node_reqs,
-                        custom_nodes_dir,
-                        log,
-                        visited,
-                    )
-            except Exception as e:
-                # Don't fail if we can't parse nested config
-                log(f"  {req.name}: could not check for nested deps: {e}")
-
-        except Exception as e:
-            log(f"  Warning: Failed to install {req.name}: {e}")