comfy-env 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

comfy_env/__init__.py

@@ -1,46 +1,4 @@
-"""
-comfy-env: Environment management for ComfyUI custom nodes.
-
-This package provides:
-- CUDA wheel resolution and in-place installation (Type 2 nodes)
-- Process isolation with separate venvs (Type 1 nodes)
-
-## Quick Start - In-Place Installation
-
-    from comfy_env import install
-
-    # Auto-discover config and install CUDA wheels
-    install()
-
-    # Or with explicit config
-    install(config="comfyui_env.toml")
-
-## Quick Start - Process Isolation
-
-    from comfy_env.workers import get_worker, TorchMPWorker
-
-    # Same-venv isolation (zero-copy tensors)
-    worker = TorchMPWorker()
-    result = worker.call(my_gpu_function, image=tensor)
-
-    # Cross-venv isolation
-    from comfy_env.workers import PersistentVenvWorker
-    worker = PersistentVenvWorker(python="/path/to/venv/bin/python")
-    result = worker.call_module("my_module", "my_func", image=tensor)
-
-## CLI
-
-    comfy-env install          # Install from config
-    comfy-env info             # Show environment info
-    comfy-env resolve pkg==1.0 # Show resolved wheel URL
-    comfy-env doctor           # Verify installation
-
-## Legacy APIs (still supported)
-
-The @isolated decorator and WorkerBridge are still available.
-"""
-
-__version__ = "0.0.11"
+__version__ = "0.0.14"
 
 from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq
 from .env.config_file import (
@@ -51,7 +9,16 @@ from .env.config_file import (
     CONFIG_FILE_NAMES,
 )
 from .env.manager import IsolatedEnvManager
-from .env.detection import detect_cuda_version, detect_gpu_info, get_gpu_summary
+from .env.cuda_gpu_detection import (
+    GPUInfo,
+    CUDAEnvironment,
+    detect_cuda_environment,
+    detect_cuda_version,
+    detect_gpu_info,
+    detect_gpus,
+    get_gpu_summary,
+    get_recommended_cuda_version,
+)
 from .env.security import (
     normalize_env_name,
     validate_dependency,
@@ -134,9 +101,14 @@ __all__ = [
     "discover_config",
     "CONFIG_FILE_NAMES",
     # Detection
+    "GPUInfo",
+    "CUDAEnvironment",
+    "detect_cuda_environment",
     "detect_cuda_version",
     "detect_gpu_info",
+    "detect_gpus",
     "get_gpu_summary",
+    "get_recommended_cuda_version",
     # Security validation
     "normalize_env_name",
     "validate_dependency",

comfy_env/env/__init__.py

@@ -1,8 +1,17 @@
 """Environment management for comfyui-isolation."""
 
-from .config import IsolatedEnv
+from .config import IsolatedEnv, ToolConfig
 from .manager import IsolatedEnvManager
-from .detection import detect_cuda_version, detect_gpu_info, get_gpu_summary
+from .cuda_gpu_detection import (
+    GPUInfo,
+    CUDAEnvironment,
+    detect_cuda_environment,
+    detect_cuda_version,
+    detect_gpu_info,
+    detect_gpus,
+    get_gpu_summary,
+    get_recommended_cuda_version,
+)
 from .platform import get_platform, PlatformProvider, PlatformPaths
 from .security import (
     normalize_env_name,
@@ -15,9 +24,17 @@ from .security import (
 __all__ = [
     "IsolatedEnv",
     "IsolatedEnvManager",
+    "ToolConfig",
+    # GPU Detection
+    "GPUInfo",
+    "CUDAEnvironment",
+    "detect_cuda_environment",
     "detect_cuda_version",
     "detect_gpu_info",
+    "detect_gpus",
     "get_gpu_summary",
+    "get_recommended_cuda_version",
+    # Platform
     "get_platform",
     "PlatformProvider",
     "PlatformPaths",

comfy_env/env/config.py

@@ -23,6 +23,14 @@ class NodeReq:
     repo: str  # GitHub repo path, e.g., "Kosinkadink/ComfyUI-VideoHelperSuite"
 
 
+@dataclass
+class ToolConfig:
+    """Configuration for an external tool like Blender."""
+    name: str
+    version: str = "latest"
+    install_dir: Optional[Path] = None
+
+
 @dataclass
 class EnvManagerConfig:
     """
@@ -35,10 +43,12 @@ class EnvManagerConfig:
         [envname.cuda]      - CUDA packages for isolated env
         [envname.packages]  - Regular packages for isolated env
         [node_reqs]         - Node dependencies
+        [tools]             - External tools (e.g., blender = "4.2")
     """
     local: LocalConfig = field(default_factory=LocalConfig)
     envs: Dict[str, "IsolatedEnv"] = field(default_factory=dict)
     node_reqs: List[NodeReq] = field(default_factory=list)
+    tools: Dict[str, ToolConfig] = field(default_factory=dict)
 
     @property
     def has_local(self) -> bool:

comfy_env/env/config_file.py

@@ -63,8 +63,8 @@ else:
     except ImportError:
         tomllib = None  # type: ignore
 
-from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq
-from .detection import detect_cuda_version
+from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, ToolConfig
+from .cuda_gpu_detection import detect_cuda_version
 
 
 # Config file name
@@ -332,7 +332,7 @@ def _substitute_vars(s: str, variables: Dict[str, str]) -> str:
 # =============================================================================
 
 # Reserved table names that are NOT isolated environments
-RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker"}
+RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools"}
 
 
 def load_config(
@@ -429,11 +429,13 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
     local = _parse_local_section(data.get("local", {}))
     envs = _parse_env_sections(data, base_dir)
     node_reqs = _parse_node_reqs(data.get("node_reqs", {}))
+    tools = _parse_tools_section(data.get("tools", {}))
 
     return EnvManagerConfig(
         local=local,
         envs=envs,
         node_reqs=node_reqs,
+        tools=tools,
     )
 
 
@@ -582,6 +584,35 @@ def _parse_node_reqs(node_reqs_data: Dict[str, Any]) -> List[NodeReq]:
     return reqs
 
 
+def _parse_tools_section(tools_data: Dict[str, Any]) -> Dict[str, ToolConfig]:
+    """Parse [tools] section.
+
+    Supports:
+        [tools]
+        blender = "4.2"
+
+    Or extended:
+        [tools.blender]
+        version = "4.2"
+        install_dir = "/custom/path"
+    """
+    tools = {}
+
+    for name, value in tools_data.items():
+        if isinstance(value, str):
+            # Simple format: blender = "4.2"
+            tools[name] = ToolConfig(name=name, version=value)
+        elif isinstance(value, dict):
+            # Extended format: [tools.blender] with version, install_dir
+            version = value.get("version", "latest")
+            install_dir = value.get("install_dir")
+            if install_dir:
+                install_dir = Path(install_dir)
+            tools[name] = ToolConfig(name=name, version=version, install_dir=install_dir)
+
+    return tools
+
+
 def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
     """Convert simple config format to full EnvManagerConfig.
 
@@ -591,6 +622,9 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
     # Parse using simple parser to get IsolatedEnv
     simple_env = _parse_config(data, base_dir)
 
+    # Parse tools section (shared between simple and full format)
+    tools = _parse_tools_section(data.get("tools", {}))
+
     # Check if this has explicit env settings (isolated venv) vs just CUDA packages (local install)
     env_section = data.get("env", {})
     has_explicit_env = bool(env_section.get("name") or env_section.get("python"))
@@ -601,6 +635,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
             local=LocalConfig(),
             envs={simple_env.name: simple_env},
             node_reqs=[],
+            tools=tools,
         )
     else:
         # Local CUDA packages only (no isolated venv)
@@ -619,4 +654,5 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
             ),
             envs={},
             node_reqs=[],
+            tools=tools,
         )

comfy_env/env/cuda_gpu_detection.py

@@ -0,0 +1,303 @@
+"""
+Robust CUDA/GPU detection with multiple fallback methods.
+
+Detection priority: NVML → PyTorch → nvidia-smi → sysfs → env vars
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import subprocess
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+CUDA_VERSION_ENV_VAR = "COMFY_ENV_CUDA_VERSION"
+
+_cache: tuple[float, "CUDAEnvironment | None"] = (0, None)
+CACHE_TTL = 60
+
+
+@dataclass
+class GPUInfo:
+    index: int
+    name: str
+    compute_capability: tuple[int, int]
+    architecture: str
+    vram_total_mb: int = 0
+    vram_free_mb: int = 0
+    uuid: str = ""
+    pci_bus_id: str = ""
+    driver_version: str = ""
+
+    def cc_str(self) -> str:
+        return f"{self.compute_capability[0]}.{self.compute_capability[1]}"
+
+    def sm_version(self) -> str:
+        return f"sm_{self.compute_capability[0]}{self.compute_capability[1]}"
+
+
+@dataclass
+class CUDAEnvironment:
+    gpus: list[GPUInfo] = field(default_factory=list)
+    driver_version: str = ""
+    cuda_runtime_version: str = ""
+    recommended_cuda: str = ""
+    detection_method: str = ""
+
+
+COMPUTE_TO_ARCH = {
+    (5, 0): "Maxwell", (5, 2): "Maxwell", (5, 3): "Maxwell",
+    (6, 0): "Pascal", (6, 1): "Pascal", (6, 2): "Pascal",
+    (7, 0): "Volta", (7, 2): "Volta", (7, 5): "Turing",
+    (8, 0): "Ampere", (8, 6): "Ampere", (8, 7): "Ampere", (8, 9): "Ada",
+    (9, 0): "Hopper",
+    (10, 0): "Blackwell", (10, 1): "Blackwell", (10, 2): "Blackwell",
+}
+
+
+def _cc_to_arch(major: int, minor: int) -> str:
+    if arch := COMPUTE_TO_ARCH.get((major, minor)):
+        return arch
+    if major >= 10: return "Blackwell"
+    if major == 9: return "Hopper"
+    if major == 8: return "Ada" if minor >= 9 else "Ampere"
+    if major == 7: return "Turing" if minor >= 5 else "Volta"
+    if major == 6: return "Pascal"
+    return "Maxwell" if major == 5 else "Unknown"
+
+
+def _parse_cc(s: str) -> tuple[int, int]:
+    try:
+        if "." in s:
+            p = s.split(".")
+            return (int(p[0]), int(p[1]))
+        if len(s) >= 2:
+            return (int(s[:-1]), int(s[-1]))
+    except (ValueError, IndexError):
+        pass
+    return (0, 0)
+
+
+def _detect_nvml() -> list[GPUInfo] | None:
+    try:
+        import pynvml
+        pynvml.nvmlInit()
+        try:
+            count = pynvml.nvmlDeviceGetCount()
+            if not count:
+                return None
+            gpus = []
+            for i in range(count):
+                h = pynvml.nvmlDeviceGetHandleByIndex(i)
+                name = pynvml.nvmlDeviceGetName(h)
+                if isinstance(name, bytes): name = name.decode()
+                cc = pynvml.nvmlDeviceGetCudaComputeCapability(h)
+                mem = pynvml.nvmlDeviceGetMemoryInfo(h)
+                gpus.append(GPUInfo(
+                    index=i, name=name, compute_capability=cc,
+                    architecture=_cc_to_arch(*cc),
+                    vram_total_mb=mem.total // (1024*1024),
+                    vram_free_mb=mem.free // (1024*1024),
+                ))
+            return gpus
+        finally:
+            pynvml.nvmlShutdown()
+    except Exception:
+        return None
+
+
+def _detect_torch() -> list[GPUInfo] | None:
+    try:
+        import torch
+        if not torch.cuda.is_available():
+            return None
+        gpus = []
+        for i in range(torch.cuda.device_count()):
+            p = torch.cuda.get_device_properties(i)
+            gpus.append(GPUInfo(
+                index=i, name=p.name,
+                compute_capability=(p.major, p.minor),
+                architecture=_cc_to_arch(p.major, p.minor),
+                vram_total_mb=p.total_memory // (1024*1024),
+            ))
+        return gpus if gpus else None
+    except Exception:
+        return None
+
+
+def _detect_smi() -> list[GPUInfo] | None:
+    try:
+        r = subprocess.run(
+            ["nvidia-smi", "--query-gpu=index,name,uuid,pci.bus_id,compute_cap,memory.total,memory.free,driver_version",
+             "--format=csv,noheader,nounits"],
+            capture_output=True, text=True, timeout=10
+        )
+        if r.returncode != 0:
+            return None
+        gpus = []
+        for line in r.stdout.strip().split("\n"):
+            if not line.strip():
+                continue
+            p = [x.strip() for x in line.split(",")]
+            if len(p) < 5:
+                continue
+            cc = _parse_cc(p[4])
+            gpus.append(GPUInfo(
+                index=int(p[0]) if p[0].isdigit() else len(gpus),
+                name=p[1], uuid=p[2] if len(p) > 2 else "",
+                pci_bus_id=p[3] if len(p) > 3 else "",
+                compute_capability=cc, architecture=_cc_to_arch(*cc),
+                vram_total_mb=int(p[5]) if len(p) > 5 and p[5].isdigit() else 0,
+                vram_free_mb=int(p[6]) if len(p) > 6 and p[6].isdigit() else 0,
+                driver_version=p[7] if len(p) > 7 else "",
+            ))
+        return gpus if gpus else None
+    except Exception:
+        return None
+
+
+def _detect_sysfs() -> list[GPUInfo] | None:
+    try:
+        pci_path = Path("/sys/bus/pci/devices")
+        if not pci_path.exists():
+            return None
+        gpus = []
+        for d in sorted(pci_path.iterdir()):
+            vendor = (d / "vendor").read_text().strip().lower() if (d / "vendor").exists() else ""
+            if "10de" not in vendor:
+                continue
+            cls = (d / "class").read_text().strip() if (d / "class").exists() else ""
+            if not (cls.startswith("0x0300") or cls.startswith("0x0302")):
+                continue
+            gpus.append(GPUInfo(
+                index=len(gpus), name=f"NVIDIA GPU", pci_bus_id=d.name,
+                compute_capability=(0, 0), architecture="Unknown"
+            ))
+        return gpus if gpus else None
+    except Exception:
+        return None
+
+
+def _get_driver_version() -> str:
+    try:
+        import pynvml
+        pynvml.nvmlInit()
+        v = pynvml.nvmlSystemGetDriverVersion()
+        pynvml.nvmlShutdown()
+        return v.decode() if isinstance(v, bytes) else v
+    except Exception:
+        pass
+    try:
+        r = subprocess.run(["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"],
+                          capture_output=True, text=True, timeout=5)
+        if r.returncode == 0:
+            return r.stdout.strip().split("\n")[0]
+    except Exception:
+        pass
+    return ""
+
+
+def _get_cuda_version() -> str:
+    try:
+        import torch
+        if torch.cuda.is_available() and torch.version.cuda:
+            return torch.version.cuda
+    except Exception:
+        pass
+    try:
+        r = subprocess.run(["nvcc", "--version"], capture_output=True, text=True, timeout=5)
+        if m := re.search(r"release (\d+\.\d+)", r.stdout):
+            return m.group(1)
+    except Exception:
+        pass
+    return ""
+
+
+def _recommended_cuda(gpus: list[GPUInfo]) -> str:
+    if override := os.environ.get(CUDA_VERSION_ENV_VAR, "").strip():
+        if "." not in override and len(override) >= 2:
+            return f"{override[:-1]}.{override[-1]}"
+        return override
+    if not gpus:
+        return ""
+    for gpu in gpus:
+        if gpu.compute_capability[0] >= 10:
+            return "12.8"  # Blackwell requires 12.8
+    for gpu in gpus:
+        cc = gpu.compute_capability
+        if cc[0] < 7 or (cc[0] == 7 and cc[1] < 5):
+            return "12.4"  # Legacy (Pascal) uses 12.4
+    return "12.8"  # Modern GPUs use 12.8
+
+
+def detect_cuda_environment(force_refresh: bool = False) -> CUDAEnvironment:
+    global _cache
+    if not force_refresh and _cache[1] and time.time() - _cache[0] < CACHE_TTL:
+        return _cache[1]
+
+    gpus, method = None, "none"
+    for name, fn in [("nvml", _detect_nvml), ("torch", _detect_torch),
+                     ("smi", _detect_smi), ("sysfs", _detect_sysfs)]:
+        if gpus := fn():
+            method = name
+            break
+
+    env = CUDAEnvironment(
+        gpus=gpus or [],
+        driver_version=_get_driver_version(),
+        cuda_runtime_version=_get_cuda_version(),
+        recommended_cuda=_recommended_cuda(gpus or []),
+        detection_method=method,
+    )
+    _cache = (time.time(), env)
+    return env
+
+
+def get_recommended_cuda_version() -> str | None:
+    if override := os.environ.get(CUDA_VERSION_ENV_VAR, "").strip():
+        if "." not in override and len(override) >= 2:
+            return f"{override[:-1]}.{override[-1]}"
+        return override
+    env = detect_cuda_environment()
+    return env.recommended_cuda or None
+
+
+def detect_gpus() -> list[GPUInfo]:
+    return detect_cuda_environment().gpus
+
+
+def detect_gpu_info() -> list[dict]:
+    """Return GPU info as list of dicts."""
+    from dataclasses import asdict
+    return [asdict(gpu) for gpu in detect_gpus()]
+
+
+def get_gpu_summary() -> str:
+    """Human-readable GPU summary."""
+    env = detect_cuda_environment()
+    if not env.gpus:
+        override = os.environ.get(CUDA_VERSION_ENV_VAR)
+        if override:
+            return f"No NVIDIA GPU detected (using {CUDA_VERSION_ENV_VAR}={override})"
+        return f"No NVIDIA GPU detected (set {CUDA_VERSION_ENV_VAR} to override)"
+
+    lines = [f"Detection: {env.detection_method}"]
+    if env.driver_version:
+        lines.append(f"Driver: {env.driver_version}")
+    if env.cuda_runtime_version:
+        lines.append(f"CUDA: {env.cuda_runtime_version}")
+    lines.append(f"Recommended: CUDA {env.recommended_cuda}")
+    lines.append("")
+    for gpu in env.gpus:
+        vram = f"{gpu.vram_total_mb}MB" if gpu.vram_total_mb else "?"
+        lines.append(f"  GPU {gpu.index}: {gpu.name} ({gpu.sm_version()}) [{gpu.architecture}] {vram}")
+    return "\n".join(lines)
+
+
+# Aliases
+detect_cuda_version = get_recommended_cuda_version

comfy_env/env/manager.py

@@ -12,7 +12,7 @@ from typing import Optional, Callable
 
 from .config import IsolatedEnv
 from .platform import get_platform, PlatformProvider
-from .detection import detect_cuda_version
+from .cuda_gpu_detection import detect_cuda_version
 from .security import (
     normalize_env_name,
     validate_dependency,
@@ -475,7 +475,7 @@ class IsolatedEnvManager:
             url_template = source["url_template"]
             url = self._substitute_template(url_template, vars_dict)
 
-            self.log(f"    Trying {source.get('name', 'unknown')}: {url[:80]}...")
+            self.log(f"    Trying {source.get('name', 'unknown')}: {url}")
             result = subprocess.run(
                 pip_args + ["--no-deps", url],
                 capture_output=True, text=True,
@@ -484,7 +484,7 @@ class IsolatedEnvManager:
             if result.returncode == 0:
                 return  # Success!
 
-            errors.append(f"{source.get('name', 'unknown')}: {result.stderr[:100]}")
+            errors.append(f"{source.get('name', 'unknown')}: {result.stderr.strip()}")
 
         # All sources failed
         raise RuntimeError(

comfy_env/env/platform/windows.py

@@ -45,12 +45,7 @@ class WindowsPlatformProvider(PlatformProvider):
                     f"Running in {shell_env.upper()} environment.\n"
                     f"This package requires native Windows Python.\n"
                     f"Please use PowerShell, Command Prompt, or native Windows terminal.")
-
-        # Check Visual C++ Redistributable
-        vc_ok, vc_error = self._check_vc_redistributable()
-        if not vc_ok:
-            return (False, vc_error)
-
+        # Note: VC++ runtime is handled by msvc-runtime package, no system check needed
         return (True, None)
 
     def _detect_shell_environment(self) -> str:
@@ -67,94 +62,6 @@ class WindowsPlatformProvider(PlatformProvider):
 
         return 'native-windows'
 
-    def _find_vc_dlls(self) -> Dict[str, Optional[Path]]:
-        """Find VC++ runtime DLLs in common locations."""
-        required_dlls = ['vcruntime140.dll', 'msvcp140.dll']
-        found = {}
-
-        # Search locations in order of preference
-        search_paths = []
-
-        # 1. Current Python environment (conda/venv)
-        if hasattr(sys, 'base_prefix'):
-            search_paths.append(Path(sys.base_prefix) / 'Library' / 'bin')
-            search_paths.append(Path(sys.base_prefix) / 'DLLs')
-        if hasattr(sys, 'prefix'):
-            search_paths.append(Path(sys.prefix) / 'Library' / 'bin')
-            search_paths.append(Path(sys.prefix) / 'DLLs')
-
-        # 2. System directories
-        system_root = os.environ.get('SystemRoot', r'C:\Windows')
-        search_paths.append(Path(system_root) / 'System32')
-
-        # 3. Visual Studio redistributable directories
-        program_files = os.environ.get('ProgramFiles', r'C:\Program Files')
-        vc_redist = Path(program_files) / 'Microsoft Visual Studio' / '2022' / 'Community' / 'VC' / 'Redist' / 'MSVC'
-        if vc_redist.exists():
-            for version_dir in vc_redist.iterdir():
-                search_paths.append(version_dir / 'x64' / 'Microsoft.VC143.CRT')
-
-        for dll_name in required_dlls:
-            found[dll_name] = None
-            for search_path in search_paths:
-                dll_path = search_path / dll_name
-                if dll_path.exists():
-                    found[dll_name] = dll_path
-                    break
-
-        return found
-
-    def bundle_vc_dlls_to_env(self, env_dir: Path) -> Tuple[bool, Optional[str]]:
-        """Bundle VC++ runtime DLLs into the isolated environment."""
-        required_dlls = ['vcruntime140.dll', 'msvcp140.dll']
-        found_dlls = self._find_vc_dlls()
-
-        # Check which DLLs are missing
-        missing = [dll for dll, path in found_dlls.items() if path is None]
-
-        if missing:
-            return (False,
-                f"Could not find VC++ DLLs to bundle: {', '.join(missing)}\n\n"
-                f"Please install Visual C++ Redistributable:\n"
-                f"  Download: https://aka.ms/vs/17/release/vc_redist.x64.exe\n"
-                f"\nAfter installation, delete the environment and try again.")
-
-        # Copy DLLs to the environment's Scripts directory
-        scripts_dir = env_dir / 'Scripts'
-
-        copied = []
-        for dll_name, source_path in found_dlls.items():
-            if source_path:
-                try:
-                    if scripts_dir.exists():
-                        scripts_target = scripts_dir / dll_name
-                        if not scripts_target.exists():
-                            shutil.copy2(source_path, scripts_target)
-                            copied.append(f"{dll_name} -> Scripts/")
-                except (OSError, IOError) as e:
-                    return (False, f"Failed to copy {dll_name}: {e}")
-
-        return (True, None)
-
-    def _check_vc_redistributable(self) -> Tuple[bool, Optional[str]]:
-        """Check if Visual C++ Redistributable DLLs are available."""
-        required_dlls = ['vcruntime140.dll', 'msvcp140.dll']
-        found_dlls = self._find_vc_dlls()
-
-        missing = [dll for dll, path in found_dlls.items() if path is None]
-
-        if missing:
-            error_msg = (
-                f"Visual C++ Redistributable DLLs not found!\n"
-                f"\nMissing: {', '.join(missing)}\n"
-                f"\nPlease install Visual C++ Redistributable for Visual Studio 2015-2022:\n"
-                f"\n  Download (64-bit): https://aka.ms/vs/17/release/vc_redist.x64.exe\n"
-                f"\nAfter installation, restart your terminal and try again."
-            )
-            return (False, error_msg)
-
-        return (True, None)
-
     def make_executable(self, path: Path) -> None:
         # No-op on Windows - executables are determined by extension
         pass

comfy_env/install.py

@@ -24,12 +24,13 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
-from .env.config import IsolatedEnv
-from .env.config_file import discover_env_config, load_env_from_file
+from .env.config import IsolatedEnv, ToolConfig
+from .env.config_file import discover_env_config, load_env_from_file, load_config, discover_config
 from .env.manager import IsolatedEnvManager
 from .errors import CUDANotFoundError, DependencyError, InstallError, WheelNotFoundError
 from .registry import PACKAGE_REGISTRY, get_cuda_short2, is_registered
 from .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
+from .tools import install_tool
 
 
 def install(
@@ -77,20 +78,38 @@ def install(
     log = log_callback or print
     node_dir = Path(node_dir) if node_dir else Path.cwd()
 
-    # Load configuration
-    env_config = _load_config(config, node_dir)
-    if env_config is None:
+    # Load full configuration (includes tools)
+    full_config = _load_full_config(config, node_dir)
+    if full_config is None:
         raise FileNotFoundError(
             "No configuration file found. "
             "Create comfyui_env.toml or specify path explicitly."
         )
 
-    log(f"Found configuration: {env_config.name}")
+    # Install tools first (e.g., Blender)
+    if full_config.tools:
+        log(f"Installing {len(full_config.tools)} tool(s)...")
+        for name, tool_config in full_config.tools.items():
+            if dry_run:
+                log(f"  Would install {name} {tool_config.version}")
+            else:
+                install_tool(tool_config, log, node_dir)
+
+    # Get environment config
+    env_config = full_config.default_env
+    if env_config is None and not full_config.has_local:
+        log("No packages to install")
+        return True
+
+    if env_config:
+        log(f"Found configuration: {env_config.name}")
 
-    if mode == "isolated":
+    if mode == "isolated" and env_config:
         return _install_isolated(env_config, node_dir, log, dry_run)
-    else:
+    elif env_config:
         return _install_inplace(env_config, node_dir, log, dry_run, verify_wheels)
+    else:
+        return True
 
 
 def _load_config(
@@ -107,6 +126,17 @@ def _load_config(
     return discover_env_config(node_dir)
 
 
+def _load_full_config(config: Optional[Union[str, Path]], node_dir: Path):
+    """Load full EnvManagerConfig (includes tools)."""
+    from .env.config import EnvManagerConfig
+    if config is not None:
+        config_path = Path(config)
+        if not config_path.is_absolute():
+            config_path = node_dir / config_path
+        return load_config(config_path, node_dir)
+    return discover_config(node_dir)
+
+
 def _install_isolated(
     env_config: IsolatedEnv,
     node_dir: Path,
@@ -140,6 +170,12 @@ def _install_inplace(
     """Install in-place into current environment using the package registry."""
     log("Installing in-place mode")
 
+    # Install MSVC runtime on Windows (required for CUDA/PyTorch native extensions)
+    if sys.platform == "win32":
+        log("Installing MSVC runtime for Windows...")
+        if not dry_run:
+            _pip_install(["msvc-runtime"], no_deps=False, log=log)
+
     # Detect runtime environment
     env = RuntimeEnv.detect()
     log(f"Detected environment: {env}")

comfy_env/resolver.py

@@ -26,7 +26,7 @@ from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 from urllib.parse import urlparse
 
-from .env.detection import detect_cuda_version, detect_gpu_info
+from .env.cuda_gpu_detection import detect_cuda_version, detect_gpu_info
 
 
 @dataclass
@@ -137,11 +137,14 @@ class RuntimeEnv:
             "py_version": self.python_version,
             "py_short": self.python_short,
             "py_minor": py_minor,
+            "py_tag": f"cp{self.python_short}",  # e.g., cp310, cp311
         }
 
         if self.cuda_version:
             result["cuda_version"] = self.cuda_version
             result["cuda_short"] = self.cuda_short
+            # cuda_major: just the major version (e.g., "12" from "12.8")
+            result["cuda_major"] = self.cuda_version.split(".")[0]
 
         if self.torch_version:
             result["torch_version"] = self.torch_version

comfy_env/tools.py

@@ -0,0 +1,221 @@
+"""
+Tool installers for external dependencies like Blender.
+
+Usage in comfy-env.toml:
+    [tools]
+    blender = "4.2"
+"""
+
+import os
+import platform
+import shutil
+import subprocess
+import tarfile
+import zipfile
+from pathlib import Path
+from typing import Callable, Optional
+from urllib.request import urlretrieve
+
+from .env.config import ToolConfig
+
+# Default install location
+DEFAULT_TOOLS_DIR = Path.home() / ".comfy-env" / "tools"
+
+# Blender download URLs by platform and version
+BLENDER_DOWNLOADS = {
+    "4.2": {
+        "linux": "https://download.blender.org/release/Blender4.2/blender-4.2.0-linux-x64.tar.xz",
+        "windows": "https://download.blender.org/release/Blender4.2/blender-4.2.0-windows-x64.zip",
+        "darwin": "https://download.blender.org/release/Blender4.2/blender-4.2.0-macos-arm64.dmg",
+    },
+    "4.3": {
+        "linux": "https://download.blender.org/release/Blender4.3/blender-4.3.0-linux-x64.tar.xz",
+        "windows": "https://download.blender.org/release/Blender4.3/blender-4.3.0-windows-x64.zip",
+        "darwin": "https://download.blender.org/release/Blender4.3/blender-4.3.0-macos-arm64.dmg",
+    },
+}
+
+
+def get_platform() -> str:
+    """Get current platform name."""
+    system = platform.system().lower()
+    if system == "linux":
+        return "linux"
+    elif system == "windows":
+        return "windows"
+    elif system == "darwin":
+        return "darwin"
+    return system
+
+
+def install_tool(
+    config: ToolConfig,
+    log: Callable[[str], None] = print,
+    base_dir: Optional[Path] = None,
+) -> Optional[Path]:
+    """Install a tool based on its config.
+
+    Args:
+        config: Tool configuration
+        log: Logging callback
+        base_dir: Base directory for tools. Tools install to base_dir/tools/<name>/
+    """
+    if config.name.lower() == "blender":
+        return install_blender(config.version, log, config.install_dir or base_dir)
+    else:
+        log(f"Unknown tool: {config.name}")
+        return None
+
+
+def install_blender(
+    version: str = "4.2",
+    log: Callable[[str], None] = print,
+    base_dir: Optional[Path] = None,
+) -> Optional[Path]:
+    """
+    Install Blender to the specified directory.
+
+    Args:
+        version: Blender version to install (e.g., "4.2")
+        log: Logging callback
+        base_dir: Base directory. Blender installs to base_dir/tools/blender/
+                  If None, uses ~/.comfy-env/tools/blender/
+
+    Returns path to blender executable if successful.
+    """
+    plat = get_platform()
+    if base_dir:
+        install_dir = base_dir / "tools" / "blender"
+    else:
+        install_dir = DEFAULT_TOOLS_DIR / "blender"
+
+    # Check if already installed
+    exe = find_blender(install_dir)
+    if exe:
+        log(f"Blender already installed: {exe}")
+        return exe
+
+    # Get download URL
+    if version not in BLENDER_DOWNLOADS:
+        log(f"Unknown Blender version: {version}. Available: {list(BLENDER_DOWNLOADS.keys())}")
+        return None
+
+    urls = BLENDER_DOWNLOADS[version]
+    if plat not in urls:
+        log(f"Blender {version} not available for {plat}")
+        return None
+
+    url = urls[plat]
+    log(f"Downloading Blender {version} for {plat}...")
+
+    install_dir.mkdir(parents=True, exist_ok=True)
+    archive_name = url.split("/")[-1]
+    archive_path = install_dir / archive_name
+
+    try:
+        # Download
+        urlretrieve(url, archive_path)
+        log(f"Downloaded to {archive_path}")
+
+        # Extract
+        log("Extracting...")
+        if archive_name.endswith(".tar.xz"):
+            with tarfile.open(archive_path, "r:xz") as tar:
+                tar.extractall(install_dir)
+        elif archive_name.endswith(".zip"):
+            with zipfile.ZipFile(archive_path, "r") as zf:
+                zf.extractall(install_dir)
+        elif archive_name.endswith(".dmg"):
+            # macOS DMG requires special handling
+            log("macOS DMG installation not yet automated. Please install manually.")
+            archive_path.unlink()
+            return None
+
+        # Clean up archive
+        archive_path.unlink()
+
+        # Find the executable
+        exe = find_blender(install_dir)
+        if exe:
+            log(f"Blender installed: {exe}")
+            return exe
+        else:
+            log("Blender extracted but executable not found")
+            return None
+
+    except Exception as e:
+        log(f"Failed to install Blender: {e}")
+        if archive_path.exists():
+            archive_path.unlink()
+        return None
+
+
+def find_blender(search_dir: Optional[Path] = None) -> Optional[Path]:
+    """Find Blender executable."""
+    # Check PATH first
+    blender_in_path = shutil.which("blender")
+    if blender_in_path:
+        return Path(blender_in_path)
+
+    # Check common locations
+    plat = get_platform()
+    search_paths = []
+
+    if search_dir:
+        search_paths.append(search_dir)
+
+    search_paths.append(DEFAULT_TOOLS_DIR / "blender")
+
+    if plat == "windows":
+        search_paths.extend([
+            Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Blender Foundation",
+            Path.home() / "AppData" / "Local" / "Blender Foundation",
+        ])
+    elif plat == "linux":
+        search_paths.extend([
+            Path("/opt/blender"),
+            Path.home() / "blender",
+        ])
+    elif plat == "darwin":
+        search_paths.append(Path("/Applications/Blender.app/Contents/MacOS"))
+
+    exe_name = "blender.exe" if plat == "windows" else "blender"
+
+    for base in search_paths:
+        if not base.exists():
+            continue
+        # Direct check
+        exe = base / exe_name
+        if exe.exists():
+            return exe
+        # Search subdirectories (for extracted archives like blender-4.2.0-linux-x64/)
+        for subdir in base.iterdir():
+            if subdir.is_dir():
+                exe = subdir / exe_name
+                if exe.exists():
+                    return exe
+
+    return None
+
+
+def ensure_blender(
+    version: str = "4.2",
+    log: Callable[[str], None] = print,
+    base_dir: Optional[Path] = None,
+) -> Optional[Path]:
+    """Ensure Blender is installed, installing if necessary.
+
+    Args:
+        version: Blender version to install
+        log: Logging callback
+        base_dir: Base directory. Searches/installs in base_dir/tools/blender/
+    """
+    if base_dir:
+        search_dir = base_dir / "tools" / "blender"
+    else:
+        search_dir = DEFAULT_TOOLS_DIR / "blender"
+
+    exe = find_blender(search_dir)
+    if exe:
+        return exe
+    return install_blender(version, log, base_dir)

{comfy_env-0.0.13.dist-info → comfy_env-0.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.13
+Version: 0.0.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

{comfy_env-0.0.13.dist-info → comfy_env-0.0.15.dist-info}/RECORD

@@ -1,21 +1,22 @@
-comfy_env/__init__.py,sha256=1EjSpAK20Z6RAXKn3onZwj2a_FIctG0E_LhWlE7SgIs,4250
+comfy_env/__init__.py,sha256=76gIAh7qFff_v_bAolXVzuWzcgvD3bp-yQGCNzba_Iw,3287
 comfy_env/cli.py,sha256=q4y_tlPyqKMZhge7XeO9VdbFVZ4dl9LZsgnnTVQYXD4,15979
 comfy_env/decorator.py,sha256=daFR5aLzshkmo5sRKhSGPcTUgIUWml7Gs6A1bfnDuyc,15718
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
-comfy_env/install.py,sha256=q8x7sQmCWMQyUjeBcbrg39eAP3ZPars54iepupMe2pE,18922
+comfy_env/install.py,sha256=fXsybbqobs_WwEEuuXgi__zQbb4hBIlZO0apiGWFb20,20365
 comfy_env/registry.py,sha256=uFCtGmWYvwGCqObXgzmArX7o5JsFNsHXxayofk3m6no,2569
-comfy_env/resolver.py,sha256=AC_xizQARVdmc8ZpGrIPQd-oA6Gv8w49OsHKltRAq5o,12251
-comfy_env/env/__init__.py,sha256=sybOBrxJCfL4Xry9NNd5xwn9hXIHudXlXDa7SpJkPCE,811
-comfy_env/env/config.py,sha256=R8JyE5iQLHKgnxXOGA8SAI7iu2eYSfXn-MsaqHoU2_A,5667
-comfy_env/env/config_file.py,sha256=6Mh2VsNvyFJuTL4_vOX0sG3Q5SMHLI1P97aY8FFvwnk,20696
-comfy_env/env/detection.py,sha256=L4kXKGs9j7Vw4Qeh6Zw5PfVZW0dN2zuJqojDPgINIhA,5653
-comfy_env/env/manager.py,sha256=MRmqg3Qw0IYUwR6FtM3ZIcGZvWcnKDyO8xbzIAxnwCk,24782
+comfy_env/resolver.py,sha256=l-AnmCE1puG6CvdpDB-KrsfG_cn_3uO2DryYizUnG_4,12474
+comfy_env/tools.py,sha256=mFNB_uq64ON5hlreH_0wTLONahDo3pBHxhQYTcTHxXE,6554
+comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,1157
+comfy_env/env/config.py,sha256=6KZPhRiW8ShhuDnX-e6_yjZHMdO_xBm02w00Q3NBJXM,5980
+comfy_env/env/config_file.py,sha256=tJ9xfmf2RghzK6PUxwTrhpvqV_5pecjC6IYYBoZ0U58,21890
+comfy_env/env/cuda_gpu_detection.py,sha256=YLuXUdWg6FeKdNyLlQAHPlveg4rTenXJ2VbeAaEi9QE,9755
+comfy_env/env/manager.py,sha256=bbV1MpURNGuBJ1sSWg_2oSU0J-dW-FhBCuHHHQxgrSM,24785
 comfy_env/env/security.py,sha256=dNSitAnfBNVdvxgBBntYw33AJaCs_S1MHb7KJhAVYzM,8171
 comfy_env/env/platform/__init__.py,sha256=Nb5MPZIEeanSMEWwqU4p4bnEKTJn1tWcwobnhq9x9IY,614
 comfy_env/env/platform/base.py,sha256=iS0ptTTVjXRwPU4qWUdvHI7jteuzxGSjWr5BUQ7hGiU,2453
 comfy_env/env/platform/darwin.py,sha256=HK3VkLT6DfesAnIXwx2IaUFHTBclF0xTQnC7azWY6Kc,1552
 comfy_env/env/platform/linux.py,sha256=xLp8FEbFqZLQrzIZBI9z3C4g23Ab1ASTHLsXDzsdCoA,2062
-comfy_env/env/platform/windows.py,sha256=nD1-bKU2rGmEJlS-cc5yWXMSA51YQtVupn-lQEO5UYA,14840
+comfy_env/env/platform/windows.py,sha256=FCOCgpzGzorY9-HueMlJUR8DxM2eH-cj9iZk6K026Is,10891
 comfy_env/ipc/__init__.py,sha256=pTjgJn5YJxLXmEvuKh3lkCEJQs-6W6_F01jfkFMUi0c,1375
 comfy_env/ipc/bridge.py,sha256=zcyN3xzV4WWBrBFNwCniPBR58dLCg46-k9TtyW5U000,16437
 comfy_env/ipc/protocol.py,sha256=gfWe5yEDUn4QWhcdWFcxn40GqxlW1Uf23j0edOzPPng,7951
@@ -32,8 +33,8 @@ comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaF
 comfy_env/workers/torch_mp.py,sha256=DsfxE3LBAWEuGtk-p-YL0UhVQ7VDh73KT_TFRxYN4-Q,12563
 comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
 comfy_env/wheel_sources.yml,sha256=ubVuQllCQGkZhLNQaG54divCwn0zLzYg4turzhnIZQ8,7150
-comfy_env-0.0.13.dist-info/METADATA,sha256=FRLYYBNxWwLm5I3vWRVxT1LYp5wvW13ibZ95PVdOaU4,5399
-comfy_env-0.0.13.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.13.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.13.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.13.dist-info/RECORD,,
+comfy_env-0.0.15.dist-info/METADATA,sha256=Fn5bJWsO2kt4UPmcCj44Oybsnd4msFl1YV-TCMf6eXQ,5399
+comfy_env-0.0.15.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.15.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.15.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.15.dist-info/RECORD,,

comfy_env/env/detection.py

@@ -1,183 +0,0 @@
-"""
-GPU detection for automatic CUDA version selection.
-
-Detects Blackwell GPUs (RTX 50xx, B100, B200) which require CUDA 12.8,
-vs older GPUs which use CUDA 12.4.
-
-This runs BEFORE PyTorch is installed, so we use nvidia-smi directly.
-"""
-
-import os
-import subprocess
-from typing import List, Dict, Optional
-
-
-# Environment variable to override CUDA version detection
-# Useful for CI environments without GPU
-CUDA_VERSION_ENV_VAR = "COMFY_ENV_CUDA_VERSION"
-
-
-def detect_gpu_info() -> List[Dict[str, str]]:
-    """
-    Detect GPU name and compute capability using nvidia-smi.
-
-    Returns:
-        List of dicts with 'name' and 'compute_cap' keys.
-        Empty list if detection fails.
-    """
-    try:
-        result = subprocess.run(
-            ["nvidia-smi", "--query-gpu=name,compute_cap", "--format=csv,noheader"],
-            capture_output=True,
-            text=True,
-            timeout=10
-        )
-        if result.returncode == 0:
-            gpus = []
-            for line in result.stdout.strip().split('\n'):
-                if not line.strip():
-                    continue
-                parts = [p.strip() for p in line.split(',')]
-                name = parts[0] if parts else "Unknown"
-                cc = parts[1] if len(parts) > 1 else "0.0"
-                gpus.append({"name": name, "compute_cap": cc})
-            return gpus
-    except FileNotFoundError:
-        # nvidia-smi not found - no NVIDIA GPU or driver not installed
-        pass
-    except subprocess.TimeoutExpired:
-        pass
-    except Exception:
-        pass
-    return []
-
-
-def is_blackwell_gpu(name: str, compute_cap: str) -> bool:
-    """
-    Check if a GPU is Blackwell architecture.
-
-    Args:
-        name: GPU name from nvidia-smi
-        compute_cap: Compute capability string (e.g., "8.9", "12.0")
-
-    Returns:
-        True if Blackwell (requires CUDA 12.8)
-    """
-    name_upper = name.upper()
-
-    # Check by name patterns
-    blackwell_patterns = [
-        "RTX 50",      # RTX 5090, 5080, 5070, etc.
-        "RTX50",       # Without space
-        "B100",        # Datacenter Blackwell
-        "B200",        # Datacenter Blackwell
-        "GB202",       # Blackwell die
-        "GB203",
-        "GB205",
-        "GB206",
-        "GB207",
-    ]
-
-    if any(pattern in name_upper for pattern in blackwell_patterns):
-        return True
-
-    # Check by compute capability (10.0+ = Blackwell)
-    try:
-        cc = float(compute_cap)
-        if cc >= 10.0:
-            return True
-    except (ValueError, TypeError):
-        pass
-
-    return False
-
-
-def is_legacy_gpu(compute_cap: str) -> bool:
-    """
-    Check if GPU is Pascal or older (requires legacy CUDA/PyTorch).
-
-    Args:
-        compute_cap: Compute capability string (e.g., "6.1", "7.5")
-
-    Returns:
-        True if Pascal or older (compute < 7.5)
-    """
-    try:
-        cc = float(compute_cap)
-        return cc < 7.5  # Turing starts at 7.5
-    except (ValueError, TypeError):
-        return False
-
-
-def detect_cuda_version() -> Optional[str]:
-    """
-    Get recommended CUDA version based on detected GPU.
-
-    Returns:
-        "12.4" for Pascal or older (compute < 7.5),
-        "12.8" for Turing or newer (compute >= 7.5),
-        None if no GPU detected and no env var override.
-
-    Environment Variable Override:
-        Set COMFY_ENV_CUDA_VERSION to override auto-detection.
-        Useful for CI environments without GPU.
-        Example: COMFY_ENV_CUDA_VERSION=12.8
-
-    GPU Architecture Reference:
-        - Pascal (GTX 10xx, P100): compute 6.0-6.1 → CUDA 12.4
-        - Turing (RTX 20xx, T4): compute 7.5 → CUDA 12.8
-        - Ampere (RTX 30xx, A100): compute 8.0-8.6 → CUDA 12.8
-        - Ada (RTX 40xx, L40): compute 8.9 → CUDA 12.8
-        - Hopper (H100): compute 9.0 → CUDA 12.8
-        - Blackwell (RTX 50xx, B100/B200): compute 10.0+ → CUDA 12.8
-    """
-    gpus = detect_gpu_info()
-    if not gpus:
-        # No GPU detected - check for env var override
-        override = os.environ.get(CUDA_VERSION_ENV_VAR)
-        if override:
-            # Normalize format (e.g., "12.8" or "128" -> "12.8")
-            override = override.strip()
-            if override and '.' not in override and len(override) >= 2:
-                # Convert "128" -> "12.8"
-                override = f"{override[:-1]}.{override[-1]}"
-            return override
-        return None
-
-    # Check if any GPU is legacy (Pascal or older)
-    for gpu in gpus:
-        if is_legacy_gpu(gpu.get("compute_cap", "0.0")):
-            return "12.4"
-
-    # Turing or newer - use modern stack
-    return "12.8"
-
-
-def get_gpu_summary() -> str:
-    """
-    Get a human-readable summary of detected GPUs.
-
-    Returns:
-        Summary string for logging.
-    """
-    gpus = detect_gpu_info()
-
-    if not gpus:
-        override = os.environ.get(CUDA_VERSION_ENV_VAR)
-        if override:
-            return f"No NVIDIA GPU detected (using {CUDA_VERSION_ENV_VAR}={override})"
-        return f"No NVIDIA GPU detected (set {CUDA_VERSION_ENV_VAR} to override)"
-
-    lines = []
-    for i, gpu in enumerate(gpus):
-        cc = gpu.get("compute_cap", "0.0")
-        is_legacy = is_legacy_gpu(cc)
-        if is_legacy:
-            tag = " [Pascal - CUDA 12.4]"
-        elif is_blackwell_gpu(gpu["name"], cc):
-            tag = " [Blackwell - CUDA 12.8]"
-        else:
-            tag = " [CUDA 12.8]"
-        lines.append(f"  GPU {i}: {gpu['name']} (sm_{cc.replace('.', '')}){tag}")
-
-    return "\n".join(lines)