comfy-env 0.1.25__tar.gz → 0.1.27__tar.gz

{comfy_env-0.1.25 → comfy_env-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.25
+Version: 0.1.27
 Summary: Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation
 Project-URL: Homepage, https://github.com/PozzettiAndrea/comfy-env
 Project-URL: Repository, https://github.com/PozzettiAndrea/comfy-env
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: numpy
 Requires-Dist: pip>=21.0
+Requires-Dist: pixi>=0.40.0
 Requires-Dist: tomli-w>=1.0.0
 Requires-Dist: tomli>=2.0.0
 Requires-Dist: uv>=0.4.0

{comfy_env-0.1.25 → comfy_env-0.1.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.1.25"
+version = "0.1.27"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}
@@ -22,6 +22,7 @@ dependencies = [
     "tomli>=2.0.0",
     "tomli-w>=1.0.0",
     "uv>=0.4.0",
+    "pixi>=0.40.0",
     "pip>=21.0",
     "numpy",
 ]

{comfy_env-0.1.25 → comfy_env-0.1.27}/src/comfy_env/config/parser.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, List, Optional
 
 import tomli
 
-from .types import ComfyEnvConfig, NodeDependency
+from .types import ComfyEnvConfig, ComfyEnvOptions, NodeDependency
 
 ROOT_CONFIG_FILE_NAME = "comfy-env-root.toml"  # Main node config
 CONFIG_FILE_NAME = "comfy-env.toml"  # Isolated folder config
@@ -43,6 +43,7 @@ def parse_config(data: Dict[str, Any]) -> ComfyEnvConfig:
     apt_packages = _ensure_list(data.pop("apt", {}).get("packages", []))
     env_vars = {str(k): str(v) for k, v in data.pop("env_vars", {}).items()}
     node_reqs = _parse_node_reqs(data.pop("node_reqs", {}))
+    options = _parse_options(data.pop("options", {}))
 
     return ComfyEnvConfig(
         python=python_version,
@@ -50,10 +51,18 @@ def parse_config(data: Dict[str, Any]) -> ComfyEnvConfig:
         apt_packages=apt_packages,
         env_vars=env_vars,
         node_reqs=node_reqs,
+        options=options,
         pixi_passthrough=data,
     )
 
 
+def _parse_options(data: Dict[str, Any]) -> ComfyEnvOptions:
+    """Parse [options] section into ComfyEnvOptions."""
+    return ComfyEnvOptions(
+        health_check_timeout=float(data.get("health_check_timeout", 2.0)),
+    )
+
+
 def _parse_node_reqs(data: Dict[str, Any]) -> List[NodeDependency]:
     return [
         NodeDependency(name=name, repo=value if isinstance(value, str) else value.get("repo", ""))

{comfy_env-0.1.25 → comfy_env-0.1.27}/src/comfy_env/config/types.py

@@ -14,6 +14,12 @@ class NodeDependency:
 NodeReq = NodeDependency  # Backwards compat
 
 
+@dataclass
+class ComfyEnvOptions:
+    """Runtime options for comfy-env."""
+    health_check_timeout: float = 2.0  # Timeout for worker health checks (seconds)
+
+
 @dataclass
 class ComfyEnvConfig:
     """Parsed comfy-env.toml configuration."""
@@ -22,6 +28,7 @@ class ComfyEnvConfig:
     apt_packages: List[str] = field(default_factory=list)
     env_vars: Dict[str, str] = field(default_factory=dict)
     node_reqs: List[NodeDependency] = field(default_factory=list)
+    options: ComfyEnvOptions = field(default_factory=ComfyEnvOptions)
     pixi_passthrough: Dict[str, Any] = field(default_factory=dict)
 
     @property

{comfy_env-0.1.25 → comfy_env-0.1.27}/src/comfy_env/install.py

@@ -151,7 +151,7 @@ def _install_via_pixi(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str],
     log("Running pixi install...")
     result = subprocess.run([str(pixi_path), "install"], cwd=node_dir, capture_output=True, text=True)
     if result.returncode != 0:
-        raise RuntimeError(f"pixi install failed: {result.stderr}")
+        raise RuntimeError(f"pixi install failed:\nstderr: {result.stderr}\nstdout: {result.stdout}")
 
     if cfg.cuda_packages and cuda_version:
         log(f"Installing CUDA packages...")
@@ -171,7 +171,7 @@ def _install_via_pixi(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str],
             result = subprocess.run([str(python_path), "-m", "pip", "install", "--no-deps", "--no-cache-dir", wheel_url],
                                    capture_output=True, text=True)
             if result.returncode != 0:
-                raise RuntimeError(f"Failed: {result.stderr}")
+                raise RuntimeError(f"Failed to install {package}:\nstderr: {result.stderr}\nstdout: {result.stdout}")
 
     # Find config file for marker
     config_path = node_dir / CONFIG_FILE_NAME

{comfy_env-0.1.25 → comfy_env-0.1.27}/src/comfy_env/isolation/workers/subprocess.py

@@ -1200,6 +1200,7 @@ class SubprocessWorker(Worker):
         env: Optional[Dict[str, str]] = None,
         name: Optional[str] = None,
         share_torch: bool = True,  # Kept for API compatibility
+        health_check_timeout: float = 2.0,
     ):
         """
         Initialize persistent worker.
@@ -1211,12 +1212,14 @@ class SubprocessWorker(Worker):
             env: Additional environment variables.
             name: Optional name for logging.
             share_torch: Ignored (kept for API compatibility).
+            health_check_timeout: Timeout in seconds for worker health checks.
         """
         self.python = Path(python)
         self.working_dir = Path(working_dir) if working_dir else Path.cwd()
         self.sys_path = sys_path or []
         self.extra_env = env or {}
         self.name = name or f"SubprocessWorker({self.python.parent.parent.name})"
+        self.health_check_timeout = health_check_timeout
 
         if not self.python.exists():
             raise FileNotFoundError(f"Python not found: {self.python}")
@@ -1267,14 +1270,18 @@ class SubprocessWorker(Worker):
     def _check_socket_health(self) -> bool:
         """Check if socket connection is healthy using a quick ping."""
         if not self._transport:
+            print(f"[{self.name}] Health check: no transport", file=sys.stderr, flush=True)
             return False
         try:
-            # Send a ping request with short timeout
+            # Send a ping request with configurable timeout
+            print(f"[{self.name}] Health check: ping (timeout={self.health_check_timeout}s)...", file=sys.stderr, flush=True)
             self._transport.send({"method": "ping"})
-            response = self._transport.recv(timeout=2.0)
-            return response is not None and response.get("status") == "pong"
+            response = self._transport.recv(timeout=self.health_check_timeout)
+            ok = response is not None and response.get("status") == "pong"
+            print(f"[{self.name}] Health check: {'ok' if ok else 'failed'}", file=sys.stderr, flush=True)
+            return ok
         except Exception as e:
-            print(f"[{self.name}] Socket health check failed: {e}", file=sys.stderr, flush=True)
+            print(f"[{self.name}] Socket health check exception: {e}", file=sys.stderr, flush=True)
             return False
 
     def _kill_worker(self) -> None:

{comfy_env-0.1.25 → comfy_env-0.1.27}/src/comfy_env/isolation/wrap.py

@@ -66,7 +66,8 @@ def _get_python_version(env_dir: Path) -> Optional[str]:
 
 
 def _get_worker(env_dir: Path, working_dir: Path, sys_path: list[str],
-                lib_path: Optional[str] = None, env_vars: Optional[dict] = None):
+                lib_path: Optional[str] = None, env_vars: Optional[dict] = None,
+                health_check_timeout: float = 2.0):
     cache_key = str(env_dir)
     with _workers_lock:
         if cache_key in _workers and _workers[cache_key].is_alive():
@@ -79,7 +80,11 @@ def _get_worker(env_dir: Path, working_dir: Path, sys_path: list[str],
         # SubprocessWorker uses a clean entry script that avoids this issue.
         from .workers.subprocess import SubprocessWorker
         print(f"[comfy-env] SubprocessWorker: {python}")
-        worker = SubprocessWorker(python=str(python), working_dir=working_dir, sys_path=sys_path, name=working_dir.name)
+        if env_vars:
+            print(f"[comfy-env] env_vars: {env_vars}")
+        if health_check_timeout != 2.0:
+            print(f"[comfy-env] health_check_timeout: {health_check_timeout}s")
+        worker = SubprocessWorker(python=str(python), working_dir=working_dir, sys_path=sys_path, name=working_dir.name, env=env_vars, health_check_timeout=health_check_timeout)
 
         _workers[cache_key] = worker
         return worker
@@ -95,7 +100,8 @@ def _shutdown_workers():
 
 
 def _wrap_node_class(cls: type, env_dir: Path, working_dir: Path, sys_path: list[str],
-                     lib_path: Optional[str] = None, env_vars: Optional[dict] = None) -> type:
+                     lib_path: Optional[str] = None, env_vars: Optional[dict] = None,
+                     health_check_timeout: float = 2.0) -> type:
     func_name = getattr(cls, "FUNCTION", None)
     if not func_name: return cls
     original = getattr(cls, func_name, None)
@@ -109,7 +115,7 @@ def _wrap_node_class(cls: type, env_dir: Path, working_dir: Path, sys_path: list
 
     @wraps(original)
     def proxy(self, **kwargs):
-        worker = _get_worker(env_dir, working_dir, sys_path, lib_path, env_vars)
+        worker = _get_worker(env_dir, working_dir, sys_path, lib_path, env_vars, health_check_timeout)
         try:
             from .tensor_utils import prepare_for_ipc_recursive
             kwargs = {k: prepare_for_ipc_recursive(v) for k, v in kwargs.items()}
@@ -161,14 +167,19 @@ def wrap_nodes() -> None:
         if not env_dir or not sp: continue
 
         env_vars = {}
+        health_check_timeout = 2.0
         try:
             import tomli
             with open(cf, "rb") as f:
-                env_vars = {str(k): str(v) for k, v in tomli.load(f).get("env_vars", {}).items()}
-        except Exception: pass
+                toml_data = tomli.load(f)
+                env_vars = {str(k): str(v) for k, v in toml_data.get("env_vars", {}).items()}
+                health_check_timeout = float(toml_data.get("options", {}).get("health_check_timeout", 2.0))
+                print(f"[comfy-env] Parsed {cf}: health_check_timeout={health_check_timeout}")
+        except Exception as e:
+            print(f"[comfy-env] Failed to parse {cf}: {e}")
         if comfyui_base: env_vars["COMFYUI_BASE"] = str(comfyui_base)
 
-        envs.append({"dir": cf.parent, "env_dir": env_dir, "sp": sp, "lib": lib, "env_vars": env_vars})
+        envs.append({"dir": cf.parent, "env_dir": env_dir, "sp": sp, "lib": lib, "env_vars": env_vars, "health_check_timeout": health_check_timeout})
 
     wrapped = 0
     for name, cls in mappings.items():
@@ -181,7 +192,7 @@ def wrap_nodes() -> None:
             try:
                 src.relative_to(e["dir"])
                 _wrap_node_class(cls, e["env_dir"], e["dir"], [str(e["sp"]), str(e["dir"])],
-                               str(e["lib"]) if e["lib"] else None, e["env_vars"])
+                               str(e["lib"]) if e["lib"] else None, e["env_vars"], e.get("health_check_timeout", 2.0))
                 wrapped += 1
                 break
             except ValueError: continue
@@ -207,11 +218,16 @@ def wrap_isolated_nodes(node_class_mappings: Dict[str, type], nodes_dir: Path) -
         return node_class_mappings
 
     env_vars = {}
+    health_check_timeout = 2.0
     try:
         import tomli
         with open(config, "rb") as f:
-            env_vars = {str(k): str(v) for k, v in tomli.load(f).get("env_vars", {}).items()}
-    except Exception: pass
+            toml_data = tomli.load(f)
+            env_vars = {str(k): str(v) for k, v in toml_data.get("env_vars", {}).items()}
+            health_check_timeout = float(toml_data.get("options", {}).get("health_check_timeout", 2.0))
+            print(f"[comfy-env] Parsed {config}: health_check_timeout={health_check_timeout}")
+    except Exception as e:
+        print(f"[comfy-env] Failed to parse {config}: {e}")
     if comfyui_base: env_vars["COMFYUI_BASE"] = str(comfyui_base)
 
     env_dir = _find_env_dir(nodes_dir)
@@ -226,6 +242,6 @@ def wrap_isolated_nodes(node_class_mappings: Dict[str, type], nodes_dir: Path) -
     print(f"[comfy-env] Wrapping {len(node_class_mappings)} nodes from {nodes_dir.name}")
     for cls in node_class_mappings.values():
         if hasattr(cls, "FUNCTION"):
-            _wrap_node_class(cls, env_dir, nodes_dir, sys_path, lib_path, env_vars)
+            _wrap_node_class(cls, env_dir, nodes_dir, sys_path, lib_path, env_vars, health_check_timeout)
 
     return node_class_mappings

{comfy_env-0.1.25 → comfy_env-0.1.27}/src/comfy_env/packages/pixi.py

@@ -19,15 +19,34 @@ PIXI_URLS = {
 
 
 def get_pixi_path() -> Optional[Path]:
-    """Find pixi in PATH or common locations."""
-    if cmd := shutil.which("pixi"): return Path(cmd)
+    """Find pixi in PATH, venv, or common user locations."""
+    # 1. PATH
+    if cmd := shutil.which("pixi"):
+        return Path(cmd)
+
+    # 2. Active venv (pip-installed pixi)
+    prefix = Path(sys.prefix)
+    candidates = []
+    if sys.platform == "win32":
+        candidates.append(prefix / "Scripts" / "pixi.exe")
+    else:
+        candidates.append(prefix / "bin" / "pixi")
+
+    # 3. User locations
     home = Path.home()
-    for p in [home / ".pixi/bin/pixi", home / ".local/bin/pixi"]:
-        candidate = p.with_suffix(".exe") if sys.platform == "win32" else p
-        if candidate.exists(): return candidate
+    candidates.extend([
+        home / ".pixi" / "bin" / ("pixi.exe" if sys.platform == "win32" else "pixi"),
+        home / ".local" / "bin" / ("pixi.exe" if sys.platform == "win32" else "pixi"),
+    ])
+
+    for c in candidates:
+        if c.exists():
+            return c
+
     return None
 
 
+
 def ensure_pixi(install_dir: Optional[Path] = None, log: Callable[[str], None] = print) -> Path:
     """Ensure pixi is installed, downloading if necessary."""
     if existing := get_pixi_path(): return existing