comfy-env 0.0.18__py3-none-any.whl → 0.0.21__py3-none-any.whl

comfy_env/decorator.py

@@ -113,6 +113,31 @@ def _clone_tensor_if_needed(obj: Any, smart_clone: bool = True) -> Any:
     return obj
 
 
+def _find_node_package_dir(source_file: Path) -> Path:
+    """
+    Find the node package root directory by searching for comfy-env.toml.
+
+    Walks up from the source file's directory until it finds a config file,
+    or falls back to heuristics if not found.
+    """
+    from .env.config_file import CONFIG_FILE_NAMES
+
+    current = source_file.parent
+
+    # Walk up the directory tree looking for config file
+    while current != current.parent:  # Stop at filesystem root
+        for config_name in CONFIG_FILE_NAMES:
+            if (current / config_name).exists():
+                return current
+        current = current.parent
+
+    # Fallback: use old heuristic if no config found
+    node_dir = source_file.parent
+    if node_dir.name == "nodes":
+        return node_dir.parent
+    return node_dir
+
+
 # ---------------------------------------------------------------------------
 # Worker Management
 # ---------------------------------------------------------------------------
@@ -262,10 +287,7 @@ def isolated(
         # Get source file info for sys.path setup
         source_file = Path(inspect.getfile(cls))
         node_dir = source_file.parent
-        if node_dir.name == "nodes":
-            node_package_dir = node_dir.parent
-        else:
-            node_package_dir = node_dir
+        node_package_dir = _find_node_package_dir(source_file)
 
         # Build sys.path for worker
         sys_path_additions = [str(node_dir)]
@@ -367,13 +389,10 @@ def isolated(
                     call_kwargs = {k: _clone_tensor_if_needed(v) for k, v in call_kwargs.items()}
 
                 # Get module name for import in worker
+                # Note: ComfyUI uses full filesystem paths as module names for custom nodes.
+                # The worker's _execute_method_call handles this by using file-based imports.
                 module_name = cls.__module__
 
-                # Handle ComfyUI's dynamic import which can set __module__ to a path
-                if module_name.startswith('/') or module_name.startswith('\\'):
-                    # Module name is a filesystem path - use the source file stem instead
-                    module_name = source_file.stem
-
                 # Call worker using appropriate method
                 if worker_config.python is None:
                     # TorchMPWorker - use call_method protocol (avoids pickle issues)

comfy_env/env/config.py

@@ -5,6 +5,18 @@ from pathlib import Path
 from typing import Dict, List, Optional
 
 
+@dataclass
+class SystemConfig:
+    """Configuration for system-level packages.
+
+    These are OS-level packages (apt, brew, etc.) that need to be installed
+    before Python packages can work properly.
+    """
+    linux: List[str] = field(default_factory=list)    # apt packages
+    darwin: List[str] = field(default_factory=list)   # brew packages (future)
+    windows: List[str] = field(default_factory=list)  # winget packages (future)
+
+
 @dataclass
 class LocalConfig:
     """Configuration for local (host environment) installs.
@@ -37,6 +49,7 @@ class EnvManagerConfig:
     Full configuration parsed from comfy-env.toml.
 
     Supports the v2 schema:
+        [system]            - System-level packages (apt, brew, etc.)
         [local.cuda]        - CUDA packages for host environment
         [local.packages]    - Regular packages for host environment
         [envname]           - Isolated env definition
@@ -45,11 +58,17 @@ class EnvManagerConfig:
         [node_reqs]         - Node dependencies
         [tools]             - External tools (e.g., blender = "4.2")
     """
+    system: SystemConfig = field(default_factory=SystemConfig)
     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_system(self) -> bool:
+        """Check if there are system packages to install."""
+        return bool(self.system.linux or self.system.darwin or self.system.windows)
+
     @property
     def has_local(self) -> bool:
         """Check if there are local packages to install."""

comfy_env/env/config_file.py

@@ -63,7 +63,7 @@ else:
     except ImportError:
         tomllib = None  # type: ignore
 
-from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, ToolConfig
+from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, SystemConfig, ToolConfig
 from .cuda_gpu_detection import detect_cuda_version
 
 
@@ -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", "tools"}
+RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools", "system"}
 
 
 def load_config(
@@ -426,12 +426,14 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
         return _convert_simple_to_full(data, base_dir)
 
     # Parse full schema
+    system = _parse_system_section(data.get("system", {}))
     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(
+        system=system,
         local=local,
         envs=envs,
         node_reqs=node_reqs,
@@ -613,6 +615,34 @@ def _parse_tools_section(tools_data: Dict[str, Any]) -> Dict[str, ToolConfig]:
     return tools
 
 
+def _parse_system_section(system_data: Dict[str, Any]) -> SystemConfig:
+    """Parse [system] section.
+
+    Supports:
+        [system]
+        linux = ["libgl1", "libopengl0"]
+        darwin = ["mesa"]  # future
+        windows = ["vcredist"]  # future
+    """
+    linux = system_data.get("linux", [])
+    darwin = system_data.get("darwin", [])
+    windows = system_data.get("windows", [])
+
+    # Ensure all are lists
+    if not isinstance(linux, list):
+        linux = [linux] if linux else []
+    if not isinstance(darwin, list):
+        darwin = [darwin] if darwin else []
+    if not isinstance(windows, list):
+        windows = [windows] if windows else []
+
+    return SystemConfig(
+        linux=linux,
+        darwin=darwin,
+        windows=windows,
+    )
+
+
 def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
     """Convert simple config format to full EnvManagerConfig.
 
@@ -622,8 +652,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)
+    # Parse tools and system sections (shared between simple and full format)
     tools = _parse_tools_section(data.get("tools", {}))
+    system = _parse_system_section(data.get("system", {}))
 
     # Check if this has explicit env settings (isolated venv) vs just CUDA packages (local install)
     env_section = data.get("env", {})
@@ -632,6 +663,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
     if has_explicit_env:
         # Isolated venv config
         return EnvManagerConfig(
+            system=system,
             local=LocalConfig(),
             envs={simple_env.name: simple_env},
             node_reqs=[],
@@ -648,6 +680,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
                 cuda_packages[req] = ""
 
         return EnvManagerConfig(
+            system=system,
             local=LocalConfig(
                 cuda_packages=cuda_packages,
                 requirements=simple_env.requirements,

comfy_env/install.py

@@ -24,13 +24,111 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
-from .env.config import IsolatedEnv, ToolConfig
+from .env.config import IsolatedEnv, SystemConfig
 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_system_packages(
+    system_config: SystemConfig,
+    log: Callable[[str], None],
+    dry_run: bool = False,
+) -> bool:
+    """
+    Install system-level packages (apt, brew, etc.).
+
+    Args:
+        system_config: SystemConfig with package lists per OS.
+        log: Logging callback.
+        dry_run: If True, show what would be installed without installing.
+
+    Returns:
+        True if installation succeeded or no packages needed.
+    """
+    platform = sys.platform
+
+    if platform.startswith("linux"):
+        packages = system_config.linux
+        if not packages:
+            return True
+
+        log(f"Installing {len(packages)} system package(s) via apt...")
+
+        if dry_run:
+            log(f"  Would install: {', '.join(packages)}")
+            return True
+
+        # Check if apt-get is available
+        if not shutil.which("apt-get"):
+            log("  Warning: apt-get not found. Cannot install system packages.")
+            log(f"  Please install manually: {', '.join(packages)}")
+            return True  # Don't fail - just warn
+
+        # Check if we can use sudo
+        sudo_available = shutil.which("sudo") is not None
+
+        try:
+            if sudo_available:
+                # Try with sudo
+                log("  Running apt-get update...")
+                update_result = subprocess.run(
+                    ["sudo", "apt-get", "update"],
+                    capture_output=True,
+                    text=True,
+                )
+                if update_result.returncode != 0:
+                    log(f"  Warning: apt-get update failed: {update_result.stderr.strip()}")
+                    # Continue anyway - packages might already be cached
+
+                log(f"  Installing: {', '.join(packages)}")
+                install_cmd = ["sudo", "apt-get", "install", "-y"] + packages
+                install_result = subprocess.run(
+                    install_cmd,
+                    capture_output=True,
+                    text=True,
+                )
+
+                if install_result.returncode != 0:
+                    log(f"  Warning: apt-get install failed: {install_result.stderr.strip()}")
+                    log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+                    return True  # Don't fail - just warn
+                else:
+                    log("  System packages installed successfully.")
+                    return True
+            else:
+                log("  Warning: sudo not available. Cannot install system packages automatically.")
+                log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+                return True  # Don't fail - just warn
+
+        except Exception as e:
+            log(f"  Warning: Failed to install system packages: {e}")
+            log(f"  Please install manually: sudo apt-get install {' '.join(packages)}")
+            return True  # Don't fail - just warn
+
+    elif platform == "darwin":
+        packages = system_config.darwin
+        if not packages:
+            return True
+
+        log(f"System packages for macOS: {', '.join(packages)}")
+        log("  Note: macOS system package installation not yet implemented.")
+        log(f"  Please install manually with Homebrew: brew install {' '.join(packages)}")
+        return True
+
+    elif platform == "win32":
+        packages = system_config.windows
+        if not packages:
+            return True
+
+        log(f"System packages for Windows: {', '.join(packages)}")
+        log("  Note: Windows system package installation not yet implemented.")
+        log(f"  Please install manually.")
+        return True
+
+    return True
 
 
 def install(
@@ -86,16 +184,10 @@ def install(
             "Create comfy-env.toml or specify path explicitly."
         )
 
-    # Install tools first (e.g., Blender)
-    # Tools are installed to ComfyUI root (shared across all nodes)
-    if full_config.tools:
-        log(f"Installing {len(full_config.tools)} tool(s)...")
-        comfyui_root = node_dir.parent.parent  # custom_nodes/../.. = ComfyUI/
-        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, comfyui_root)
+    # Install system packages first (apt, brew, etc.)
+    # These need to be installed before Python packages that depend on them
+    if full_config.has_system:
+        _install_system_packages(full_config.system, log, dry_run)
 
     # Get environment config
     env_config = full_config.default_env

comfy_env/workers/torch_mp.py

@@ -106,6 +106,190 @@ def _worker_loop(queue_in, queue_out, sys_path_additions=None):
             break
 
 
+class PathBasedModuleFinder:
+    """
+    Meta path finder that handles ComfyUI's path-based module names.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This finder intercepts imports of such modules and loads them from disk.
+    """
+
+    def find_spec(self, fullname, path, target=None):
+        import importlib.util
+        import os
+
+        # Only handle path-based module names (starting with /)
+        if not fullname.startswith('/'):
+            return None
+
+        # Parse the module name to find base path and submodule parts
+        parts = fullname.split('.')
+        base_path = parts[0]
+        submodule_parts = parts[1:] if len(parts) > 1 else []
+
+        # Walk through parts to find where path ends and module begins
+        for i, part in enumerate(submodule_parts):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # Remaining parts are module names
+                submodule_parts = submodule_parts[i:]
+                break
+        else:
+            # All parts were path components
+            submodule_parts = []
+
+        # Determine the file to load
+        if submodule_parts:
+            # We're importing a submodule
+            current_path = base_path
+            for part in submodule_parts[:-1]:
+                current_path = os.path.join(current_path, part)
+
+            submod = submodule_parts[-1]
+            submod_file = os.path.join(current_path, submod + '.py')
+            submod_pkg = os.path.join(current_path, submod, '__init__.py')
+
+            if os.path.exists(submod_file):
+                return importlib.util.spec_from_file_location(fullname, submod_file)
+            elif os.path.exists(submod_pkg):
+                return importlib.util.spec_from_file_location(
+                    fullname, submod_pkg,
+                    submodule_search_locations=[os.path.join(current_path, submod)]
+                )
+        else:
+            # Top-level path-based module
+            if os.path.isdir(base_path):
+                init_path = os.path.join(base_path, "__init__.py")
+                if os.path.exists(init_path):
+                    return importlib.util.spec_from_file_location(
+                        fullname, init_path,
+                        submodule_search_locations=[base_path]
+                    )
+            elif os.path.isfile(base_path):
+                return importlib.util.spec_from_file_location(fullname, base_path)
+
+        return None
+
+
+# Global flag to track if we've installed the finder
+_path_finder_installed = False
+
+
+def _ensure_path_finder_installed():
+    """Install the PathBasedModuleFinder if not already installed."""
+    import sys
+    global _path_finder_installed
+    if not _path_finder_installed:
+        sys.meta_path.insert(0, PathBasedModuleFinder())
+        _path_finder_installed = True
+        logger.debug("[comfy_env] Installed PathBasedModuleFinder for path-based module names")
+
+
+def _load_path_based_module(module_name: str):
+    """
+    Load a module that has a filesystem path as its name.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This function handles that case by using file-based imports.
+    """
+    import importlib.util
+    import os
+    import sys
+
+    # Check if it's already in sys.modules
+    if module_name in sys.modules:
+        return sys.modules[module_name]
+
+    # Check if module_name contains submodule parts (e.g., "/path/to/pkg.submod.subsubmod")
+    # In this case, we need to load the parent packages first
+    if '.' in module_name:
+        parts = module_name.split('.')
+        # Find where the path ends and module parts begin
+        # The path part won't exist as a directory when combined with module parts
+        base_path = parts[0]
+        submodule_parts = []
+
+        for i, part in enumerate(parts[1:], 1):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # This and remaining parts are module names, not path components
+                submodule_parts = parts[i:]
+                break
+
+        if submodule_parts:
+            # Load parent package first
+            parent_module = _load_path_based_module(base_path)
+
+            # Now load submodules
+            current_module = parent_module
+            current_name = base_path
+            for submod in submodule_parts:
+                current_name = f"{current_name}.{submod}"
+                if current_name in sys.modules:
+                    current_module = sys.modules[current_name]
+                else:
+                    # Try to import as attribute or load from file
+                    if hasattr(current_module, submod):
+                        current_module = getattr(current_module, submod)
+                    else:
+                        # Try to load the submodule file
+                        if hasattr(current_module, '__path__'):
+                            for parent_path in current_module.__path__:
+                                submod_file = os.path.join(parent_path, submod + '.py')
+                                submod_pkg = os.path.join(parent_path, submod, '__init__.py')
+                                if os.path.exists(submod_file):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_file)
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    current_module.__package__ = f"{base_path}.{'.'.join(submodule_parts[:-1])}" if len(submodule_parts) > 1 else base_path
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                                elif os.path.exists(submod_pkg):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_pkg,
+                                        submodule_search_locations=[os.path.dirname(submod_pkg)])
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                        else:
+                            raise ModuleNotFoundError(f"Cannot find submodule {submod} in {current_name}")
+            return current_module
+
+    # Simple path-based module (no submodule parts)
+    if os.path.isdir(module_name):
+        init_path = os.path.join(module_name, "__init__.py")
+        submodule_search_locations = [module_name]
+    else:
+        init_path = module_name
+        submodule_search_locations = None
+
+    if not os.path.exists(init_path):
+        raise ModuleNotFoundError(f"Cannot find module at path: {module_name}")
+
+    spec = importlib.util.spec_from_file_location(
+        module_name,
+        init_path,
+        submodule_search_locations=submodule_search_locations
+    )
+    module = importlib.util.module_from_spec(spec)
+
+    # Set up package attributes for relative imports
+    if os.path.isdir(module_name):
+        module.__path__ = [module_name]
+        module.__package__ = module_name
+    else:
+        module.__package__ = module_name.rsplit('.', 1)[0] if '.' in module_name else ''
+
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+
+    return module
+
+
 def _execute_method_call(module_name: str, class_name: str, method_name: str,
                          self_state: dict, kwargs: dict) -> Any:
     """
@@ -114,9 +298,28 @@ def _execute_method_call(module_name: str, class_name: str, method_name: str,
     This function imports the class fresh and calls the original (un-decorated) method.
     """
     import importlib
+    import os
+    import sys
 
     # Import the module
-    module = importlib.import_module(module_name)
+    logger.debug(f"Attempting to import module_name={module_name}")
+
+    # Check if module_name is a filesystem path (ComfyUI uses paths as module names)
+    # This happens because ComfyUI's load_custom_node uses the full path as sys_module_name
+    if module_name.startswith('/') or (os.sep in module_name and not module_name.startswith('.')):
+        # Check if the base path exists to confirm it's a path-based module
+        base_path = module_name.split('.')[0] if '.' in module_name else module_name
+        if os.path.exists(base_path):
+            logger.debug(f"Detected path-based module name, using file-based import")
+            # Install the meta path finder to handle relative imports within the package
+            _ensure_path_finder_installed()
+            module = _load_path_based_module(module_name)
+        else:
+            # Doesn't look like a valid path, try standard import
+            module = importlib.import_module(module_name)
+    else:
+        # Standard module name - use importlib.import_module
+        module = importlib.import_module(module_name)
     cls = getattr(module, class_name)
 
     # Create instance with proper __slots__ handling

{comfy_env-0.0.18.dist-info → comfy_env-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.18
+Version: 0.0.21
 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
@@ -126,7 +126,7 @@ comfy-env resolve nvdiffrast==0.4.0
 comfy-env doctor
 ```
 
-## Configuration
+## Configurations
 
 ### comfy-env.toml
 

{comfy_env-0.0.18.dist-info → comfy_env-0.0.21.dist-info}/RECORD

@@ -1,14 +1,13 @@
 comfy_env/__init__.py,sha256=76gIAh7qFff_v_bAolXVzuWzcgvD3bp-yQGCNzba_Iw,3287
 comfy_env/cli.py,sha256=X-GCQMP0mtMcE3ZgkT-VLQ4Gq3UUvcb_Ux_NClEFhgI,15975
-comfy_env/decorator.py,sha256=FwM6O0eIYK1FlKmniE4sJyzLLIr4mVg3ON-PnuTF2cw,16056
+comfy_env/decorator.py,sha256=6JCKwLHaZtOLVDexs_gh_-NtS2ZK0V7nGCPqkyeYEAA,16688
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
-comfy_env/install.py,sha256=K0sayQ8HVG5t7XpxrAouhicFYnqSXpaQeDa5DgHO6L4,21064
+comfy_env/install.py,sha256=txjQh5mdtFt0uQL7682LWgH0-311TflunaKv-n0XlYM,24510
 comfy_env/registry.py,sha256=uFCtGmWYvwGCqObXgzmArX7o5JsFNsHXxayofk3m6no,2569
 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=h2EJqg1bf5GamBwXV2uXeYZ4fBpW9nqs0WG1Xzlqjmc,5978
-comfy_env/env/config_file.py,sha256=tJ9xfmf2RghzK6PUxwTrhpvqV_5pecjC6IYYBoZ0U58,21890
+comfy_env/env/config.py,sha256=r1olWRFbXzSSU24Zkn_TVFVujaf_lEX6LAYEgfBYo3U,6765
+comfy_env/env/config_file.py,sha256=-NdK6i0LKKGK6uNqXKvBlQGnwdHpMCaNkYpbxLDAgNY,22918
 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
@@ -30,11 +29,11 @@ comfy_env/workers/__init__.py,sha256=IKZwOvrWOGqBLDUIFAalg4CdqzJ_YnAdxo2Ha7gZTJ0
 comfy_env/workers/base.py,sha256=ZILYXlvGCWuCZXmjKqfG8VeD19ihdYaASdlbasl2BMo,2312
 comfy_env/workers/pool.py,sha256=MtjeOWfvHSCockq8j1gfnxIl-t01GSB79T5N4YB82Lg,6956
 comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
-comfy_env/workers/torch_mp.py,sha256=1cNhcrCWZ9E6AHCIEMC3vDLo_qjyV2wuQh5iZslg0Hg,13222
+comfy_env/workers/torch_mp.py,sha256=4YSNPn7hALrvMVbkO4RkTeFTcc0lhfLMk5QTWjY4PHw,22134
 comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
 comfy_env/wheel_sources.yml,sha256=nSZ8XB_I5JXQGB7AgC6lHs_IXMd9Kcno10artNL8BKw,7775
-comfy_env-0.0.18.dist-info/METADATA,sha256=2AL5DPZlU5EXPmtM9OhEt-FZ8wlIw6lzs5kGMGW4dKI,5399
-comfy_env-0.0.18.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.18.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.18.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.18.dist-info/RECORD,,
+comfy_env-0.0.21.dist-info/METADATA,sha256=UvyKIRRV4zWGCvxgQu-Og_Y7wNC--tzcBCFab4PvAYw,5400
+comfy_env-0.0.21.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.21.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.21.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.21.dist-info/RECORD,,

comfy_env/tools.py

@@ -1,221 +0,0 @@
-"""
-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)