comfy-env 0.0.13__tar.gz → 0.0.15__tar.gz

{comfy_env-0.0.13 → comfy_env-0.0.15}/PKG-INFO

@@ -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 → comfy_env-0.0.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.13"
+version = "0.0.15"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}

{comfy_env-0.0.13 → comfy_env-0.0.15}/src/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-0.0.13 → comfy_env-0.0.15}/src/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-0.0.13 → comfy_env-0.0.15}/src/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-0.0.13 → comfy_env-0.0.15}/src/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-0.0.15/src/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-0.0.13 → comfy_env-0.0.15}/src/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-0.0.13 → comfy_env-0.0.15}/src/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