comfy-env 0.0.50__tar.gz → 0.0.52__tar.gz

{comfy_env-0.0.50 → comfy_env-0.0.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.50
+Version: 0.0.52
 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.50 → comfy_env-0.0.52}/pyproject.toml

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

{comfy_env-0.0.50 → comfy_env-0.0.52}/src/comfy_env/pixi.py

@@ -233,12 +233,23 @@ def create_pixi_toml(
     elif sys.platform == "win32":
         lines.append('platforms = ["win-64"]')
 
+    # System requirements - specify glibc version for proper wheel resolution
+    # Ubuntu 22.04+ has glibc 2.35, enabling manylinux_2_35 wheels
+    if sys.platform == "linux":
+        lines.append("")
+        lines.append("[system-requirements]")
+        lines.append('libc = { family = "glibc", version = "2.35" }')
+
     lines.append("")
 
     # Dependencies section (conda packages)
     lines.append("[dependencies]")
     lines.append(f'python = "{env_config.python}.*"')
 
+    # On Windows, use MKL BLAS to avoid OpenBLAS crashes (numpy blas_fpe_check issue)
+    if sys.platform == "win32":
+        lines.append('libblas = { version = "*", build = "*mkl" }')
+
     for pkg in conda.packages:
         # Parse package spec (name=version or name>=version or just name)
         if "=" in pkg and not pkg.startswith("="):

{comfy_env-0.0.50 → comfy_env-0.0.52}/src/comfy_env/stub_imports.py

@@ -156,19 +156,26 @@ def _get_import_names_from_pixi(node_dir: Path) -> Set[str]:
     """
     import_names = set()
 
-    # Find the pixi site-packages
-    pixi_lib = node_dir / ".pixi" / "envs" / "default" / "lib"
+    pixi_base = node_dir / ".pixi" / "envs" / "default"
 
-    if not pixi_lib.exists():
-        return import_names
-
-    # Find the python version directory (e.g., python3.11)
-    python_dirs = list(pixi_lib.glob("python3.*"))
-    if not python_dirs:
-        return import_names
+    # Find site-packages (different paths on Windows vs Linux)
+    # Linux: .pixi/envs/default/lib/python3.x/site-packages
+    # Windows: .pixi/envs/default/Lib/site-packages
+    site_packages = None
 
-    site_packages = python_dirs[0] / "site-packages"
-    if not site_packages.exists():
+    # Try Windows path first (Lib/site-packages)
+    win_site = pixi_base / "Lib" / "site-packages"
+    if win_site.exists():
+        site_packages = win_site
+    else:
+        # Try Linux path (lib/python3.x/site-packages)
+        pixi_lib = pixi_base / "lib"
+        if pixi_lib.exists():
+            python_dirs = list(pixi_lib.glob("python3.*"))
+            if python_dirs:
+                site_packages = python_dirs[0] / "site-packages"
+
+    if site_packages is None or not site_packages.exists():
         return import_names
 
     # Scan for importable modules

{comfy_env-0.0.50 → comfy_env-0.0.52}/src/comfy_env/workers/venv.py

@@ -252,10 +252,29 @@ def _serialize_for_ipc(obj, visited=None):
 # Worker script template - minimal, runs in target venv
 _WORKER_SCRIPT = '''
 import sys
+import os
 import json
 import traceback
 from types import SimpleNamespace
 
+# On Windows, add DLL directories for proper library loading
+if sys.platform == "win32" and hasattr(os, "add_dll_directory"):
+    _host_python_dir = os.environ.get("COMFYUI_HOST_PYTHON_DIR")
+    if _host_python_dir:
+        try:
+            os.add_dll_directory(_host_python_dir)
+            _dlls_dir = os.path.join(_host_python_dir, "DLLs")
+            if os.path.isdir(_dlls_dir):
+                os.add_dll_directory(_dlls_dir)
+        except Exception:
+            pass
+    _pixi_library_bin = os.environ.get("COMFYUI_PIXI_LIBRARY_BIN")
+    if _pixi_library_bin:
+        try:
+            os.add_dll_directory(_pixi_library_bin)
+        except Exception:
+            pass
+
 def _deserialize_isolated_objects(obj):
     """Reconstruct objects serialized with __isolated_object__ marker."""
     if isinstance(obj, dict):
@@ -475,12 +494,29 @@ class VenvWorker(Worker):
             env.update(self.extra_env)
             env["COMFYUI_ISOLATION_WORKER"] = "1"
 
-            # For conda/pixi environments, add lib dir to LD_LIBRARY_PATH
+            # For conda/pixi environments, add lib dir to LD_LIBRARY_PATH (Linux)
             lib_dir = self.python.parent.parent / "lib"
             if lib_dir.is_dir():
                 existing = env.get("LD_LIBRARY_PATH", "")
                 env["LD_LIBRARY_PATH"] = f"{lib_dir}:{existing}" if existing else str(lib_dir)
 
+            # On Windows, pass host Python directory and pixi Library/bin for DLL loading
+            if sys.platform == "win32":
+                env["COMFYUI_HOST_PYTHON_DIR"] = str(Path(sys.executable).parent)
+
+                # For pixi environments with MKL, add Library/bin to PATH for DLL loading
+                # Pixi has python.exe directly in env dir, not in Scripts/
+                env_dir = self.python.parent
+                library_bin = env_dir / "Library" / "bin"
+                if library_bin.is_dir():
+                    existing_path = env.get("PATH", "")
+                    env["PATH"] = f"{env_dir};{library_bin};{existing_path}"
+                    env["COMFYUI_PIXI_LIBRARY_BIN"] = str(library_bin)
+                    # Allow duplicate OpenMP libraries (MKL's libiomp5md.dll + PyTorch's libomp.dll)
+                    env["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+                    # Use UTF-8 encoding for stdout/stderr to handle Unicode symbols
+                    env["PYTHONIOENCODING"] = "utf-8"
+
             # Run subprocess
             cmd = [
                 str(self.python),
@@ -572,8 +608,13 @@ import json
 import socket
 import struct
 import traceback
+import faulthandler
 from types import SimpleNamespace
 
+# Enable faulthandler to dump traceback on SIGSEGV/SIGABRT/etc
+faulthandler.enable(file=sys.stderr, all_threads=True)
+print("[worker] Faulthandler enabled", flush=True)
+
 # On Windows, add host Python's DLL directories so packages like opencv can find VC++ runtime
 if sys.platform == "win32":
     _host_python_dir = os.environ.get("COMFYUI_HOST_PYTHON_DIR")
@@ -587,6 +628,15 @@ if sys.platform == "win32":
         except Exception:
             pass
 
+    # For pixi environments with MKL, add Library/bin for MKL DLLs
+    _pixi_library_bin = os.environ.get("COMFYUI_PIXI_LIBRARY_BIN")
+    if _pixi_library_bin and hasattr(os, "add_dll_directory"):
+        try:
+            os.add_dll_directory(_pixi_library_bin)
+            print(f"[worker] Added pixi Library/bin to DLL search: {_pixi_library_bin}", flush=True)
+        except Exception as e:
+            print(f"[worker] Failed to add pixi Library/bin: {e}", flush=True)
+
 # =============================================================================
 # Object Reference System - keep complex objects in worker, pass refs to host
 # =============================================================================
@@ -741,20 +791,24 @@ def _deserialize_isolated_objects(obj):
 
 
 def main():
+    print("[worker] Starting...", flush=True)
     # Get socket address from command line
     if len(sys.argv) < 2:
         print("Usage: worker.py <socket_addr>", file=sys.stderr)
         sys.exit(1)
     socket_addr = sys.argv[1]
+    print(f"[worker] Connecting to {socket_addr}...", flush=True)
 
     # Connect to host process
     sock = _connect(socket_addr)
     transport = SocketTransport(sock)
+    print("[worker] Connected, waiting for config...", flush=True)
 
     # Read config as first message
     config = transport.recv()
     if not config:
         return
+    print("[worker] Got config, setting up paths...", flush=True)
 
     # Setup sys.path
     for p in config.get("sys_paths", []):
@@ -762,10 +816,13 @@ def main():
             sys.path.insert(0, p)
 
     # Import torch after path setup
+    print("[worker] Importing torch...", flush=True)
     import torch
+    print(f"[worker] Torch imported: {torch.__version__}", flush=True)
 
     # Signal ready
     transport.send({"status": "ready"})
+    print("[worker] Ready, entering request loop...", flush=True)
 
     # Process requests
     while True:
@@ -784,30 +841,41 @@ def main():
             module_name = request["module"]
             inputs_path = request.get("inputs_path")
             outputs_path = request.get("outputs_path")
+            print(f"[worker] Request: {request_type} {module_name}", flush=True)
 
             # Load inputs
             if inputs_path:
+                print(f"[worker] Loading inputs from {inputs_path}...", flush=True)
                 inputs = torch.load(inputs_path, weights_only=False)
+                print(f"[worker] Deserializing isolated objects...", flush=True)
                 inputs = _deserialize_isolated_objects(inputs)
                 # Resolve any object references from previous node calls
+                print(f"[worker] Resolving object references...", flush=True)
                 inputs = _deserialize_input(inputs)
+                print(f"[worker] Inputs ready: {list(inputs.keys())}", flush=True)
             else:
                 inputs = {}
 
             # Import module
+            print(f"[worker] Importing module {module_name}...", flush=True)
             module = __import__(module_name, fromlist=[""])
+            print(f"[worker] Module imported", flush=True)
 
             if request_type == "call_method":
                 class_name = request["class_name"]
                 method_name = request["method_name"]
                 self_state = request.get("self_state")
+                print(f"[worker] Getting class {class_name}...", flush=True)
 
                 cls = getattr(module, class_name)
+                print(f"[worker] Creating instance...", flush=True)
                 instance = object.__new__(cls)
                 if self_state:
                     instance.__dict__.update(self_state)
+                print(f"[worker] Calling {method_name}...", flush=True)
                 method = getattr(instance, method_name)
                 result = method(**inputs)
+                print(f"[worker] Method returned", flush=True)
             else:
                 func_name = request["func"]
                 func = getattr(module, func_name)
@@ -892,6 +960,10 @@ class PersistentVenvWorker(Worker):
         self._socket_addr: Optional[str] = None
         self._transport: Optional[SocketTransport] = None
 
+        # Stderr buffer for crash diagnostics
+        self._stderr_buffer: List[str] = []
+        self._stderr_lock = threading.Lock()
+
         # Write worker script to temp file
         self._worker_script = self._temp_dir / "persistent_worker.py"
         self._worker_script.write_text(_PERSISTENT_WORKER_SCRIPT)
@@ -950,6 +1022,22 @@ class PersistentVenvWorker(Worker):
         if sys.platform == "win32":
             env["COMFYUI_HOST_PYTHON_DIR"] = str(Path(sys.executable).parent)
 
+            # For pixi environments with MKL, add Library/bin to PATH for DLL loading
+            # MKL DLLs are in .pixi/envs/default/Library/bin/
+            # Pixi has python.exe directly in env dir, not in Scripts/
+            env_dir = self.python.parent
+            library_bin = env_dir / "Library" / "bin"
+            if library_bin.is_dir():
+                existing_path = env.get("PATH", "")
+                # Add env dir and Library/bin to PATH
+                env["PATH"] = f"{env_dir};{library_bin};{existing_path}"
+                # Also pass as env var so worker can use os.add_dll_directory()
+                env["COMFYUI_PIXI_LIBRARY_BIN"] = str(library_bin)
+                # Allow duplicate OpenMP libraries (MKL's libiomp5md.dll + PyTorch's libomp.dll)
+                env["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+                # Use UTF-8 encoding for stdout/stderr to handle Unicode symbols
+                env["PYTHONIOENCODING"] = "utf-8"
+
         # Find ComfyUI base and set env var for folder_paths stub
         comfyui_base = self._find_comfyui_base()
         if comfyui_base:
@@ -964,13 +1052,17 @@ class PersistentVenvWorker(Worker):
             [str(self.python), str(self._worker_script), self._socket_addr],
             stdin=subprocess.DEVNULL,
             stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,  # Merge stdout/stderr for forwarding
+            stderr=subprocess.PIPE,  # Capture stderr separately for crash diagnostics
             cwd=str(self.working_dir),
             env=env,
         )
 
-        # Start output forwarding thread
-        def forward_output():
+        # Clear stderr buffer for new process
+        with self._stderr_lock:
+            self._stderr_buffer.clear()
+
+        # Start stdout forwarding thread
+        def forward_stdout():
             try:
                 for line in self._process.stdout:
                     if isinstance(line, bytes):
@@ -979,22 +1071,43 @@ class PersistentVenvWorker(Worker):
                     sys.stderr.flush()
             except:
                 pass
-        self._output_thread = threading.Thread(target=forward_output, daemon=True)
-        self._output_thread.start()
+        self._stdout_thread = threading.Thread(target=forward_stdout, daemon=True)
+        self._stdout_thread.start()
+
+        # Start stderr capture thread (buffer for crash diagnostics)
+        def capture_stderr():
+            try:
+                for line in self._process.stderr:
+                    if isinstance(line, bytes):
+                        line = line.decode('utf-8', errors='replace')
+                    # Print to terminal AND buffer for crash reporting
+                    sys.stderr.write(f"  [stderr] {line}")
+                    sys.stderr.flush()
+                    with self._stderr_lock:
+                        self._stderr_buffer.append(line.rstrip())
+                        # Keep last 50 lines
+                        if len(self._stderr_buffer) > 50:
+                            self._stderr_buffer.pop(0)
+            except:
+                pass
+        self._stderr_thread = threading.Thread(target=capture_stderr, daemon=True)
+        self._stderr_thread.start()
 
         # Accept connection from worker with timeout
         self._server_socket.settimeout(60)
         try:
             client_sock, _ = self._server_socket.accept()
         except socket.timeout:
-            stderr = ""
+            # Collect stderr from buffer
+            time.sleep(0.2)  # Give stderr thread time to capture
+            with self._stderr_lock:
+                stderr = "\n".join(self._stderr_buffer) if self._stderr_buffer else "(no stderr captured)"
             try:
                 self._process.kill()
-                stdout, _ = self._process.communicate(timeout=5)
-                stderr = stdout.decode('utf-8', errors='replace') if stdout else ""
+                self._process.wait(timeout=5)
             except:
                 pass
-            raise RuntimeError(f"{self.name}: Worker failed to connect (timeout). output: {stderr}")
+            raise RuntimeError(f"{self.name}: Worker failed to connect (timeout).\nStderr:\n{stderr}")
         finally:
             self._server_socket.settimeout(None)
 
@@ -1035,7 +1148,33 @@ class PersistentVenvWorker(Worker):
         self._transport.send(request)
 
         # Read response with timeout
-        response = self._transport.recv(timeout=timeout)
+        try:
+            response = self._transport.recv(timeout=timeout)
+        except ConnectionError as e:
+            # Socket closed - check if worker process died
+            self._shutdown = True
+            time.sleep(0.2)  # Give process time to fully exit and stderr to flush
+            exit_code = None
+            if self._process:
+                exit_code = self._process.poll()
+
+            # Get captured stderr
+            with self._stderr_lock:
+                stderr_output = "\n".join(self._stderr_buffer) if self._stderr_buffer else "(no stderr captured)"
+
+            if exit_code is not None:
+                raise RuntimeError(
+                    f"{self.name}: Worker process died with exit code {exit_code}. "
+                    f"This usually indicates a crash in native code (CGAL, pymeshlab, etc.).\n"
+                    f"Stderr:\n{stderr_output}"
+                ) from e
+            else:
+                # Process still alive but socket closed - something weird
+                raise RuntimeError(
+                    f"{self.name}: Socket closed but worker process still running. "
+                    f"This may indicate a protocol error or worker bug.\n"
+                    f"Stderr:\n{stderr_output}"
+                ) from e
 
         if response is None:
             # Timeout - kill process