comfy-env 0.0.54__tar.gz → 0.0.55__tar.gz

{comfy_env-0.0.54 → comfy_env-0.0.55}/PKG-INFO

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

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

{comfy_env-0.0.54 → comfy_env-0.0.55}/src/comfy_env/isolation.py

@@ -158,7 +158,11 @@ def _wrap_node_class(
 
     @wraps(original_method)
     def proxy(self, **kwargs):
+        print(f"[comfy-env] PROXY CALLED: {cls.__name__}.{func_name}", flush=True)
+        print(f"[comfy-env]   kwargs keys: {list(kwargs.keys())}", flush=True)
+
         worker = _get_worker(env_name, python_path, working_dir, sys_path)
+        print(f"[comfy-env]   worker alive: {worker.is_alive()}", flush=True)
 
         # Clone tensors for IPC if needed
         try:
@@ -168,6 +172,7 @@ def _wrap_node_class(
         except ImportError:
             pass  # No torch available, skip cloning
 
+        print(f"[comfy-env]   calling worker.call_method...", flush=True)
         result = worker.call_method(
             module_name=module_name,
             class_name=cls.__name__,
@@ -176,6 +181,7 @@ def _wrap_node_class(
             kwargs=kwargs,
             timeout=600.0,
         )
+        print(f"[comfy-env]   call_method returned", flush=True)
 
         # Clone result tensors
         try:

{comfy_env-0.0.54 → comfy_env-0.0.55}/src/comfy_env/pixi.py

@@ -253,19 +253,26 @@ def create_pixi_toml(
         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("="):
-            # Has version spec
-            if ">=" in pkg:
-                name, version = pkg.split(">=", 1)
-                lines.append(f'{name} = ">={version}"')
-            elif "==" in pkg:
-                name, version = pkg.split("==", 1)
-                lines.append(f'{name} = "=={version}"')
-            else:
-                # Single = means exact version in conda
-                name, version = pkg.split("=", 1)
-                lines.append(f'{name} = "=={version}"')
+        # Parse package spec (name=version or name>=version or name<version or just name)
+        if ">=" in pkg:
+            name, version = pkg.split(">=", 1)
+            lines.append(f'{name} = ">={version}"')
+        elif "<=" in pkg:
+            name, version = pkg.split("<=", 1)
+            lines.append(f'{name} = "<={version}"')
+        elif "==" in pkg:
+            name, version = pkg.split("==", 1)
+            lines.append(f'{name} = "=={version}"')
+        elif ">" in pkg:
+            name, version = pkg.split(">", 1)
+            lines.append(f'{name} = ">{version}"')
+        elif "<" in pkg:
+            name, version = pkg.split("<", 1)
+            lines.append(f'{name} = "<{version}"')
+        elif "=" in pkg and not pkg.startswith("="):
+            # Single = means exact version in conda
+            name, version = pkg.split("=", 1)
+            lines.append(f'{name} = "=={version}"')
         else:
             # No version, use any
             lines.append(f'{pkg} = "*"')
@@ -282,16 +289,22 @@ def create_pixi_toml(
     if local_wheels_dir:
         local_wheels = list(Path(local_wheels_dir).glob("comfy_env-*.whl"))
         if local_wheels:
-            # Use relative path from node_dir
-            rel_path = os.path.relpath(local_wheels[0], node_dir)
-            special_deps["comfy-env"] = f'{{ path = "{rel_path}" }}'
+            # Copy wheel to node_dir (next to pixi.toml) for simple relative path
+            wheel_name = local_wheels[0].name
+            wheel_dest = node_dir / wheel_name
+            if not wheel_dest.exists():
+                shutil.copy(local_wheels[0], wheel_dest)
+            # Reference with simple relative path (forward slashes, no backslash issues)
+            special_deps["comfy-env"] = f'{{ path = "./{wheel_name}" }}'
         else:
             pypi_deps.append("comfy-env")
     else:
         # Check for local editable comfy-env at ~/utils/comfy-env
         local_comfy_env = Path.home() / "utils" / "comfy-env"
         if local_comfy_env.exists() and (local_comfy_env / "pyproject.toml").exists():
-            special_deps["comfy-env"] = f'{{ path = "{local_comfy_env}", editable = true }}'
+            # Use forward slashes for TOML compatibility
+            path_str = local_comfy_env.as_posix()
+            special_deps["comfy-env"] = f'{{ path = "{path_str}", editable = true }}'
         else:
             pypi_deps.append("comfy-env")
 
@@ -544,20 +557,38 @@ def pixi_install(
 
     log("pixi install completed successfully!")
 
-    # Create _env_{name} symlink for compatibility with uv backend
+    # Create _env_{name} link for compatibility with uv backend
     # This ensures code that expects _env_envname/bin/python works with pixi
     symlink_path = node_dir / f"_env_{env_config.name}"
     pixi_env_path = node_dir / ".pixi" / "envs" / "default"
 
     if pixi_env_path.exists():
-        # Remove existing symlink or directory if present
-        if symlink_path.is_symlink():
-            symlink_path.unlink()
+        # Remove existing symlink/junction or directory if present
+        if symlink_path.is_symlink() or (sys.platform == "win32" and symlink_path.is_dir()):
+            # On Windows, junctions appear as directories but can be removed with rmdir
+            try:
+                symlink_path.unlink()
+            except (OSError, PermissionError):
+                # Junction on Windows - remove with rmdir (doesn't delete contents)
+                subprocess.run(["cmd", "/c", "rmdir", str(symlink_path)], capture_output=True)
         elif symlink_path.exists():
             shutil.rmtree(symlink_path)
 
-        symlink_path.symlink_to(pixi_env_path)
-        log(f"Created symlink: _env_{env_config.name} -> .pixi/envs/default")
+        # On Windows, use directory junctions (no admin required) instead of symlinks
+        if sys.platform == "win32":
+            # mklink /J creates a directory junction (no admin privileges needed)
+            result = subprocess.run(
+                ["cmd", "/c", "mklink", "/J", str(symlink_path), str(pixi_env_path)],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode == 0:
+                log(f"Created junction: _env_{env_config.name} -> .pixi/envs/default")
+            else:
+                log(f"Warning: Failed to create junction: {result.stderr}")
+        else:
+            symlink_path.symlink_to(pixi_env_path)
+            log(f"Created symlink: _env_{env_config.name} -> .pixi/envs/default")
 
     return True
 

{comfy_env-0.0.54 → comfy_env-0.0.55}/src/comfy_env/stub_imports.py

@@ -5,9 +5,9 @@ This module provides automatic import stubbing for packages that exist only
 in the isolated pixi environment, not in the host ComfyUI Python.
 
 How it works:
-1. Read package names from comfy-env.toml
-2. Look up their import names from top_level.txt in the pixi environment
-3. Register import hooks that provide stub modules for those imports
+1. Scan pixi environment's site-packages for installed packages
+2. Look up import names from top_level.txt in .dist-info directories
+3. Inject stub modules directly into sys.modules for missing packages
 4. Stubs allow class definitions to parse without the real packages
 5. Real packages are used when FUNCTION runs in the isolated worker
 
@@ -22,13 +22,16 @@ Usage:
 import sys
 import types
 from pathlib import Path
-from typing import Dict, List, Optional, Set
+from typing import List, Set
+
+
+def _log(msg: str) -> None:
+    """Log with immediate flush to stderr (visible on Windows subprocess)."""
+    print(msg, file=sys.stderr, flush=True)
 
 
 class _StubModule(types.ModuleType):
-    """
-    A stub module that accepts any attribute access or call.
-    """
+    """A stub module that accepts any attribute access or call."""
 
     def __init__(self, name: str):
         super().__init__(name)
@@ -46,9 +49,7 @@ class _StubModule(types.ModuleType):
 
 
 class _StubObject:
-    """
-    A stub object that accepts any operation.
-    """
+    """A stub object that accepts any operation."""
 
     def __init__(self, name: str = "stub"):
         self._stub_name = name
@@ -99,57 +100,12 @@ class _StubObject:
     def __contains__(self, item): return False
 
 
-class _StubFinder:
-    """Import hook finder that provides stub modules for specified packages."""
-
-    def __init__(self, stub_packages: Set[str]):
-        self.stub_packages = stub_packages
-
-    def find_module(self, fullname: str, path=None):
-        top_level = fullname.split('.')[0]
-        if top_level in self.stub_packages:
-            return _StubLoader(self.stub_packages)
-        return None
-
-
-class _StubLoader:
-    """Import hook loader that creates stub modules."""
-
-    def __init__(self, stub_packages: Set[str]):
-        self.stub_packages = stub_packages
-
-    def load_module(self, fullname: str):
-        if fullname in sys.modules:
-            return sys.modules[fullname]
-
-        module = _StubModule(fullname)
-        module.__loader__ = self
-
-        if '.' in fullname:
-            parent = fullname.rsplit('.', 1)[0]
-            module.__package__ = parent
-            if parent not in sys.modules:
-                self.load_module(parent)
-        else:
-            module.__package__ = fullname
-
-        sys.modules[fullname] = module
-        return module
-
-
-def _normalize_package_name(name: str) -> str:
-    """Normalize package name for comparison (PEP 503)."""
-    return name.lower().replace('-', '_').replace('.', '_')
-
-
 def _get_import_names_from_pixi(node_dir: Path) -> Set[str]:
     """
-    Get import names by scanning the pixi environment's site-packages.
+    Get import names from pixi environment using top_level.txt metadata.
 
-    Finds all importable packages by looking for:
-    1. Directories with __init__.py (packages)
-    2. .py files (single-file modules)
-    3. .so/.pyd files (extension modules)
+    This properly maps package names to import names (e.g., libigl -> igl,
+    PyYAML -> yaml) by reading the canonical top_level.txt files.
 
     Returns:
         Set of import names that should be stubbed.
@@ -159,16 +115,11 @@ def _get_import_names_from_pixi(node_dir: Path) -> Set[str]:
     pixi_base = node_dir / ".pixi" / "envs" / "default"
 
     # 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
-
-    # 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.*"))
@@ -178,25 +129,44 @@ def _get_import_names_from_pixi(node_dir: Path) -> Set[str]:
     if site_packages is None or not site_packages.exists():
         return import_names
 
-    # Scan for importable modules
+    _log(f"[comfy-env] Scanning: {site_packages}")
+
+    # PRIMARY: Read top_level.txt from all .dist-info directories
+    for dist_info in site_packages.glob("*.dist-info"):
+        top_level_file = dist_info / "top_level.txt"
+        if top_level_file.exists():
+            try:
+                for line in top_level_file.read_text(encoding="utf-8").splitlines():
+                    name = line.strip()
+                    if name and not name.startswith('#'):
+                        # Extract just the top-level name
+                        top_name = name.replace('\\', '/').split('/')[0]
+                        if top_name:
+                            import_names.add(top_name)
+            except Exception:
+                pass
+
+    # FALLBACK: Scan for packages/modules not covered by dist-info
     for item in site_packages.iterdir():
         name = item.name
 
-        # Skip private/internal items
         if name.startswith('_') or name.startswith('.'):
             continue
-
-        # Skip dist-info and egg-info directories
         if name.endswith('.dist-info') or name.endswith('.egg-info'):
             continue
-
-        # Skip common non-module items
         if name in {'bin', 'share', 'include', 'etc'}:
             continue
 
         # Package directory (has __init__.py)
+        if item.is_dir() and (item / "__init__.py").exists():
+            import_names.add(name)
+            continue
+
+        # Namespace package (directory without __init__.py but has submodules)
         if item.is_dir():
-            if (item / "__init__.py").exists():
+            has_py = any(item.glob("*.py"))
+            has_subpkg = any((item / d / "__init__.py").exists() for d in item.iterdir() if d.is_dir())
+            if has_py or has_subpkg:
                 import_names.add(name)
             continue
 
@@ -206,11 +176,9 @@ def _get_import_names_from_pixi(node_dir: Path) -> Set[str]:
             continue
 
         # Extension module (.so on Linux, .pyd on Windows)
-        if '.cpython-' in name and (name.endswith('.so') or name.endswith('.pyd')):
-            # Extract module name: foo.cpython-311-x86_64-linux-gnu.so -> foo
+        if name.endswith('.so') or name.endswith('.pyd'):
             module_name = name.split('.')[0]
             import_names.add(module_name)
-            continue
 
     return import_names
 
@@ -230,14 +198,14 @@ def _filter_to_missing(import_names: Set[str]) -> Set[str]:
         except ImportError:
             missing.add(name)
         except Exception:
-            # Other errors - don't stub, let real error surface
-            pass
+            # Other errors (DLL load, etc.) - stub these too
+            missing.add(name)
 
     return missing
 
 
-# Track whether we've already set up stubs
-_stub_finder: Optional[_StubFinder] = None
+# Track what we stubbed for cleanup
+_stubbed_modules: Set[str] = set()
 
 
 def setup_isolated_imports(init_file: str) -> List[str]:
@@ -258,7 +226,7 @@ def setup_isolated_imports(init_file: str) -> List[str]:
 
         from .nodes import NODE_CLASS_MAPPINGS  # Now works!
     """
-    global _stub_finder
+    global _stubbed_modules
 
     node_dir = Path(init_file).resolve().parent
 
@@ -266,52 +234,37 @@ def setup_isolated_imports(init_file: str) -> List[str]:
     pixi_imports = _get_import_names_from_pixi(node_dir)
 
     if not pixi_imports:
-        print("[comfy-env] No pixi environment found, skipping import stubbing")
+        _log("[comfy-env] No pixi environment found")
         return []
 
     # Filter to only those missing in host
     missing = _filter_to_missing(pixi_imports)
 
     if not missing:
-        print("[comfy-env] All pixi packages available in host, no stubbing needed")
+        _log("[comfy-env] All packages available in host")
         return []
 
-    # Remove old finder if exists
-    if _stub_finder is not None:
-        try:
-            sys.meta_path.remove(_stub_finder)
-        except ValueError:
-            pass
-
-    # Register new finder
-    _stub_finder = _StubFinder(missing)
-    sys.meta_path.insert(0, _stub_finder)
+    # Direct injection into sys.modules - simple and reliable
+    for name in missing:
+        if name not in sys.modules:
+            sys.modules[name] = _StubModule(name)
+            _stubbed_modules.add(name)
 
-    stubbed = sorted(missing)
+    stubbed = sorted(_stubbed_modules)
     if len(stubbed) <= 10:
-        print(f"[comfy-env] Stubbed {len(stubbed)} imports: {', '.join(stubbed)}")
+        _log(f"[comfy-env] Injected {len(stubbed)} stubs: {', '.join(stubbed)}")
     else:
-        print(f"[comfy-env] Stubbed {len(stubbed)} imports: {', '.join(stubbed[:10])}... and {len(stubbed)-10} more")
+        _log(f"[comfy-env] Injected {len(stubbed)} stubs: {', '.join(stubbed[:10])}... +{len(stubbed)-10} more")
 
     return stubbed
 
 
 def cleanup_stubs():
-    """Remove the stub import hooks."""
-    global _stub_finder
+    """Remove injected stub modules from sys.modules."""
+    global _stubbed_modules
 
-    if _stub_finder is not None:
-        try:
-            sys.meta_path.remove(_stub_finder)
-        except ValueError:
-            pass
-
-        # Remove stubbed modules from sys.modules
-        to_remove = [
-            name for name in sys.modules
-            if isinstance(sys.modules[name], _StubModule)
-        ]
-        for name in to_remove:
+    for name in list(_stubbed_modules):
+        if name in sys.modules and isinstance(sys.modules[name], _StubModule):
             del sys.modules[name]
 
-        _stub_finder = None
+    _stubbed_modules.clear()

{comfy_env-0.0.54 → comfy_env-0.0.55}/src/comfy_env/workers/venv.py

@@ -613,7 +613,77 @@ 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)
+
+# Pre-import bpy FIRST to avoid DLL conflicts with numpy/torch/MKL
+# bpy's DLLs must be loaded before other packages load conflicting versions
+try:
+    import bpy
+    print("[worker] Pre-imported bpy successfully", file=sys.stderr, flush=True)
+except ImportError as e:
+    # bpy not available in this environment - that's fine
+    pass
+except Exception as e:
+    print(f"[worker] bpy pre-import warning: {e}", file=sys.stderr, flush=True)
+
+# Watchdog: dump all thread stacks every 60 seconds to catch hangs
+import threading
+import tempfile as _tempfile
+_watchdog_log = os.path.join(_tempfile.gettempdir(), "comfy_worker_watchdog.log")
+def _watchdog():
+    import time
+    import io
+    tick = 0
+    while True:
+        time.sleep(60)
+        tick += 1
+        # Capture stack dump to string
+        buf = io.StringIO()
+        faulthandler.dump_traceback(file=buf, all_threads=True)
+        dump = buf.getvalue()
+
+        # Write to file
+        with open(_watchdog_log, "a", encoding="utf-8") as f:
+            f.write(f"\\n=== WATCHDOG TICK {tick} ({time.strftime('%H:%M:%S')}) ===\\n")
+            f.write(dump)
+            f.write("=== END ===\\n")
+            f.flush()
+            os.fsync(f.fileno())
+
+        # Also print
+        print(f"\\n=== WATCHDOG TICK {tick} ===", flush=True)
+        print(dump, flush=True)
+        print("=== END ===\\n", flush=True)
+
+_watchdog_thread = threading.Thread(target=_watchdog, daemon=True)
+_watchdog_thread.start()
+print(f"[worker] Watchdog started, logging to: {_watchdog_log}", flush=True)
+
+# File-based logging for debugging (persists even if stdout/stderr are swallowed)
+import tempfile
+_worker_log_file = os.path.join(tempfile.gettempdir(), "comfy_worker_debug.log")
+def wlog(msg):
+    """Log to file only - stdout causes pipe buffer deadlock after many requests."""
+    try:
+        with open(_worker_log_file, "a", encoding="utf-8") as f:
+            import time
+            f.write(f"{time.strftime('%H:%M:%S')} {msg}\\n")
+            f.flush()
+            os.fsync(f.fileno())
+    except Exception:
+        pass
+    # NOTE: Don't print to stdout here! After 50+ requests the pipe buffer
+    # fills up and causes deadlock (parent blocked on recv, worker blocked on print)
+
+wlog(f"[worker] === Worker starting, log file: {_worker_log_file} ===")
+
+# Debug: print PATH at startup
+_path_sep = ";" if sys.platform == "win32" else ":"
+_path_parts = os.environ.get("PATH", "").split(_path_sep)
+print(f"[worker] PATH has {len(_path_parts)} entries:", file=sys.stderr, flush=True)
+for _i, _p in enumerate(_path_parts[:15]):
+    print(f"[worker]   [{_i}] {_p}", file=sys.stderr, flush=True)
+if len(_path_parts) > 15:
+    print(f"[worker]   ... and {len(_path_parts) - 15} more", file=sys.stderr, flush=True)
 
 # On Windows, add host Python's DLL directories so packages like opencv can find VC++ runtime
 if sys.platform == "win32":
@@ -633,9 +703,9 @@ if sys.platform == "win32":
     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)
+            wlog(f"[worker] Added pixi Library/bin to DLL search: {_pixi_library_bin}")
         except Exception as e:
-            print(f"[worker] Failed to add pixi Library/bin: {e}", flush=True)
+            wlog(f"[worker] Failed to add pixi Library/bin: {e}")
 
 # =============================================================================
 # Object Reference System - keep complex objects in worker, pass refs to host
@@ -805,24 +875,25 @@ def _deserialize_isolated_objects(obj):
 
 
 def main():
-    print("[worker] Starting...", flush=True)
+    wlog("[worker] Starting...")
     # Get socket address from command line
     if len(sys.argv) < 2:
-        print("Usage: worker.py <socket_addr>", file=sys.stderr)
+        wlog("Usage: worker.py <socket_addr>")
         sys.exit(1)
     socket_addr = sys.argv[1]
-    print(f"[worker] Connecting to {socket_addr}...", flush=True)
+    wlog(f"[worker] Connecting to {socket_addr}...")
 
     # Connect to host process
     sock = _connect(socket_addr)
     transport = SocketTransport(sock)
-    print("[worker] Connected, waiting for config...", flush=True)
+    wlog("[worker] Connected, waiting for config...")
 
     # Read config as first message
     config = transport.recv()
     if not config:
+        wlog("[worker] No config received, exiting")
         return
-    print("[worker] Got config, setting up paths...", flush=True)
+    wlog("[worker] Got config, setting up paths...")
 
     # Setup sys.path
     for p in config.get("sys_paths", []):
@@ -830,66 +901,77 @@ def main():
             sys.path.insert(0, p)
 
     # Import torch after path setup
-    print("[worker] Importing torch...", flush=True)
+    wlog("[worker] Importing torch...")
     import torch
-    print(f"[worker] Torch imported: {torch.__version__}", flush=True)
+    wlog(f"[worker] Torch imported: {torch.__version__}")
 
     # Signal ready
     transport.send({"status": "ready"})
-    print("[worker] Ready, entering request loop...", flush=True)
+    wlog("[worker] Ready, entering request loop...")
 
     # Process requests
+    request_num = 0
     while True:
+        request_num += 1
+        wlog(f"[worker] Waiting for request #{request_num}...")
         try:
             request = transport.recv()
             if not request:
+                wlog("[worker] Empty request received, exiting loop")
                 break
-        except Exception:
+        except Exception as e:
+            wlog(f"[worker] Exception receiving request: {e}")
             break
 
         if request.get("method") == "shutdown":
+            wlog("[worker] Shutdown requested")
             break
 
+        if request.get("method") == "ping":
+            # Health check - respond immediately
+            transport.send({"status": "pong"})
+            continue
+
         try:
             request_type = request.get("type", "call_module")
             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)
+            wlog(f"[worker] Request: {request_type} {module_name}")
 
             # Load inputs
             if inputs_path:
-                print(f"[worker] Loading inputs from {inputs_path}...", flush=True)
+                wlog(f"[worker] Loading inputs from {inputs_path}...")
                 inputs = torch.load(inputs_path, weights_only=False)
-                print(f"[worker] Deserializing isolated objects...", flush=True)
+                wlog(f"[worker] Deserializing isolated objects...")
                 inputs = _deserialize_isolated_objects(inputs)
                 # Resolve any object references from previous node calls
-                print(f"[worker] Resolving object references...", flush=True)
+                wlog(f"[worker] Resolving object references...")
                 inputs = _deserialize_input(inputs)
-                print(f"[worker] Inputs ready: {list(inputs.keys())}", flush=True)
+                wlog(f"[worker] Inputs ready: {list(inputs.keys())}")
             else:
                 inputs = {}
 
             # Import module
-            print(f"[worker] Importing module {module_name}...", flush=True)
+            wlog(f"[worker] Importing module {module_name}...")
             module = __import__(module_name, fromlist=[""])
-            print(f"[worker] Module imported", flush=True)
+            wlog(f"[worker] Module imported")
 
             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)
+                wlog(f"[worker] Getting class {class_name}...")
 
                 cls = getattr(module, class_name)
-                print(f"[worker] Creating instance...", flush=True)
+                wlog(f"[worker] Creating instance...")
                 instance = object.__new__(cls)
                 if self_state:
                     instance.__dict__.update(self_state)
-                print(f"[worker] Calling {method_name}...", flush=True)
+                wlog(f"[worker] Calling {method_name}...")
                 method = getattr(instance, method_name)
                 result = method(**inputs)
-                print(f"[worker] Method returned", flush=True)
+                wlog(f"[worker] Method returned")
             else:
                 func_name = request["func"]
                 func = getattr(module, func_name)
@@ -1000,13 +1082,53 @@ class PersistentVenvWorker(Worker):
             current = current.parent
         return None
 
+    def _check_socket_health(self) -> bool:
+        """Check if socket connection is healthy using a quick ping."""
+        if not self._transport:
+            return False
+        try:
+            # Send a ping request with short timeout
+            self._transport.send({"method": "ping"})
+            response = self._transport.recv(timeout=2.0)
+            return response is not None and response.get("status") == "pong"
+        except Exception as e:
+            print(f"[{self.name}] Socket health check failed: {e}", file=sys.stderr, flush=True)
+            return False
+
+    def _kill_worker(self) -> None:
+        """Kill the worker process and clean up resources."""
+        if self._process:
+            try:
+                self._process.kill()
+                self._process.wait(timeout=5)
+            except:
+                pass
+            self._process = None
+        if self._transport:
+            try:
+                self._transport.close()
+            except:
+                pass
+            self._transport = None
+        if self._server_socket:
+            try:
+                self._server_socket.close()
+            except:
+                pass
+            self._server_socket = None
+
     def _ensure_started(self):
         """Start persistent worker subprocess if not running."""
         if self._shutdown:
             raise RuntimeError(f"{self.name}: Worker has been shut down")
 
         if self._process is not None and self._process.poll() is None:
-            return  # Already running
+            # Process is running, but check if socket is healthy
+            if self._transport and self._check_socket_health():
+                return  # All good
+            # Socket is dead/unhealthy - restart worker
+            print(f"[{self.name}] Socket unhealthy, restarting worker...", file=sys.stderr, flush=True)
+            self._kill_worker()
 
         # Clean up any previous socket
         if self._transport:
@@ -1041,16 +1163,28 @@ class PersistentVenvWorker(Worker):
             # Pixi has python.exe directly in env dir, not in Scripts/
             env_dir = self.python.parent
             library_bin = env_dir / "Library" / "bin"
+
+            # COMPLETE DLL ISOLATION: Build minimal PATH from scratch
+            # Only include Windows system directories + pixi environment
+            # This prevents DLL conflicts from mingw, conda, etc.
+            windir = os.environ.get("WINDIR", r"C:\Windows")
+            minimal_path_parts = [
+                str(env_dir),  # Pixi env (python.exe location)
+                str(env_dir / "Scripts"),  # Pixi Scripts
+                str(env_dir / "Lib" / "site-packages" / "bpy"),  # bpy DLLs
+                f"{windir}\\System32",  # Core Windows DLLs
+                f"{windir}",  # Windows directory
+                f"{windir}\\System32\\Wbem",  # WMI tools
+            ]
             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"
+                minimal_path_parts.insert(1, str(library_bin))  # MKL DLLs
+
+            env["PATH"] = ";".join(minimal_path_parts)
+            env["COMFYUI_PIXI_LIBRARY_BIN"] = str(library_bin) if library_bin.is_dir() else ""
+            # 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()
@@ -1062,32 +1196,62 @@ class PersistentVenvWorker(Worker):
         all_sys_path = [str(stubs_dir), str(self.working_dir)] + self.sys_path
 
         # Launch subprocess with the venv Python, passing socket address
+        # For pixi environments, use "pixi run python" to get proper environment activation
+        # (CONDA_PREFIX, Library paths, etc.) which fixes DLL loading issues with bpy
+        is_pixi = '.pixi' in str(self.python)
+        print(f"[PersistentVenvWorker] is_pixi={is_pixi}, python={self.python}", flush=True)
+        if is_pixi:
+            # Find pixi project root (parent of .pixi directory)
+            pixi_project = self.python
+            while pixi_project.name != '.pixi' and pixi_project.parent != pixi_project:
+                pixi_project = pixi_project.parent
+            pixi_project = pixi_project.parent  # Go up from .pixi to project root
+            pixi_toml = pixi_project / "pixi.toml"
+            print(f"[PersistentVenvWorker] pixi_toml={pixi_toml}, exists={pixi_toml.exists()}", flush=True)
+
+            if pixi_toml.exists():
+                cmd = ["pixi", "run", "--manifest-path", str(pixi_toml),
+                       "python", str(self._worker_script), self._socket_addr]
+                # Clean PATH to remove ct-env entries that have conflicting DLLs
+                # Pixi will add its own environment paths
+                path_sep = ";" if sys.platform == "win32" else ":"
+                current_path = env.get("PATH", "")
+                # Filter out ct-envs and conda/mamba paths that could conflict
+                clean_path_parts = [
+                    p for p in current_path.split(path_sep)
+                    if not any(x in p.lower() for x in (".ct-envs", "conda", "mamba", "miniforge", "miniconda", "anaconda"))
+                ]
+                env["PATH"] = path_sep.join(clean_path_parts)
+                launch_env = env
+            else:
+                cmd = [str(self.python), str(self._worker_script), self._socket_addr]
+                launch_env = env
+        else:
+            cmd = [str(self.python), str(self._worker_script), self._socket_addr]
+            launch_env = env
+
+        print(f"[PersistentVenvWorker] launching cmd={cmd[:3]}...", flush=True)
+        if launch_env:
+            path_sep = ";" if sys.platform == "win32" else ":"
+            path_parts = launch_env.get("PATH", "").split(path_sep)
+            print(f"[PersistentVenvWorker] PATH has {len(path_parts)} entries:", flush=True)
+            for i, p in enumerate(path_parts[:10]):  # Show first 10
+                print(f"[PersistentVenvWorker]   [{i}] {p}", flush=True)
+            if len(path_parts) > 10:
+                print(f"[PersistentVenvWorker]   ... and {len(path_parts) - 10} more", flush=True)
         self._process = subprocess.Popen(
-            [str(self.python), str(self._worker_script), self._socket_addr],
+            cmd,
             stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
+            stdout=subprocess.DEVNULL,  # DEVNULL to prevent pipe buffer deadlock
             stderr=subprocess.PIPE,  # Capture stderr separately for crash diagnostics
             cwd=str(self.working_dir),
-            env=env,
+            env=launch_env,
         )
 
         # 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):
-                        line = line.decode('utf-8', errors='replace')
-                    sys.stderr.write(f"  {line}")
-                    sys.stderr.flush()
-            except:
-                pass
-        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:
@@ -1224,8 +1388,13 @@ class PersistentVenvWorker(Worker):
         Returns:
             Return value of the method.
         """
+        import sys
+        print(f"[PersistentVenvWorker] call_method: {module_name}.{class_name}.{method_name}", file=sys.stderr, flush=True)
+
         with self._lock:
+            print(f"[PersistentVenvWorker] acquired lock, ensuring started...", file=sys.stderr, flush=True)
             self._ensure_started()
+            print(f"[PersistentVenvWorker] worker started/confirmed", file=sys.stderr, flush=True)
 
             timeout = timeout or 600.0
             call_id = str(uuid.uuid4())[:8]
@@ -1237,8 +1406,11 @@ class PersistentVenvWorker(Worker):
             try:
                 # Serialize kwargs
                 if kwargs:
+                    print(f"[PersistentVenvWorker] serializing kwargs...", file=sys.stderr, flush=True)
                     serialized_kwargs = _serialize_for_ipc(kwargs)
+                    print(f"[PersistentVenvWorker] saving to {inputs_path}...", file=sys.stderr, flush=True)
                     torch.save(serialized_kwargs, str(inputs_path))
+                    print(f"[PersistentVenvWorker] saved inputs", file=sys.stderr, flush=True)
 
                 # Send request with class info
                 request = {
@@ -1250,7 +1422,9 @@ class PersistentVenvWorker(Worker):
                     "inputs_path": str(inputs_path) if kwargs else None,
                     "outputs_path": str(outputs_path),
                 }
+                print(f"[PersistentVenvWorker] sending request via socket...", file=sys.stderr, flush=True)
                 response = self._send_request(request, timeout)
+                print(f"[PersistentVenvWorker] got response: {response.get('status')}", file=sys.stderr, flush=True)
 
                 if response.get("status") == "error":
                     raise WorkerError(