comfy-env 0.0.43__py3-none-any.whl → 0.0.45__py3-none-any.whl

comfy_env/env/manager.py

@@ -4,6 +4,7 @@ IsolatedEnvManager - Creates and manages isolated Python environments.
 Uses uv for fast environment creation and package installation.
 """
 
+import os
 import subprocess
 import shutil
 import sys
@@ -383,13 +384,19 @@ class IsolatedEnvManager:
 
                 if "wheel_template" in config:
                     # Direct wheel URL from template
-                    effective_version = version or config.get("default_version")
-                    if not effective_version:
-                        raise RuntimeError(f"Package {package} requires version (no default in registry)")
-
-                    vars_dict["version"] = effective_version
-                    wheel_url = self._substitute_template(config["wheel_template"], vars_dict)
-                    self.log(f"  Installing {package}=={effective_version}...")
+                    template = config["wheel_template"]
+
+                    # Only require version if template uses {version}
+                    effective_version = None
+                    if "{version}" in template:
+                        effective_version = version or config.get("default_version")
+                        if not effective_version:
+                            raise RuntimeError(f"Package {package} requires version (no default in registry)")
+                        vars_dict["version"] = effective_version
+
+                    wheel_url = self._substitute_template(template, vars_dict)
+                    version_str = f"=={effective_version}" if effective_version else ""
+                    self.log(f"  Installing {package}{version_str}...")
                     self.log(f"    URL: {wheel_url}")
                     result = subprocess.run(
                         pip_args + ["--no-deps", wheel_url],
@@ -398,6 +405,19 @@ class IsolatedEnvManager:
                     if result.returncode != 0:
                         raise RuntimeError(f"Failed to install {package}: {result.stderr}")
 
+                elif "find_links" in config:
+                    # find_links: pip resolves wheel from index URL
+                    find_links_url = config["find_links"]
+                    effective_version = version or config.get("default_version")
+                    pkg_spec = f"{package}=={effective_version}" if effective_version else package
+                    self.log(f"  Installing {pkg_spec} from {find_links_url}...")
+                    result = subprocess.run(
+                        pip_args + ["--no-deps", "--find-links", find_links_url, pkg_spec],
+                        capture_output=True, text=True,
+                    )
+                    if result.returncode != 0:
+                        raise RuntimeError(f"Failed to install {package}: {result.stderr}")
+
                 elif "package_name" in config:
                     # PyPI variant (e.g., spconv-cu124)
                     pkg_name = self._substitute_template(config["package_name"], vars_dict)
@@ -411,7 +431,7 @@ class IsolatedEnvManager:
                         raise RuntimeError(f"Failed to install {package}: {result.stderr}")
 
                 else:
-                    raise RuntimeError(f"Package {package} in registry but missing wheel_template or package_name")
+                    raise RuntimeError(f"Package {package} in registry but missing wheel_template, find_links, or package_name")
 
             else:
                 # Not in registry - error
@@ -434,10 +454,24 @@ class IsolatedEnvManager:
         uv = self._find_uv()
 
         self.log("Installing comfy-env (for worker support)...")
+
+        # Check for local wheel in COMFY_LOCAL_WHEELS directory (set by comfy-test --local)
+        install_target = "comfy-env @ git+https://github.com/PozzettiAndrea/comfy-env"
+        wheels_dir = os.environ.get("COMFY_LOCAL_WHEELS")
+        self.log(f"  COMFY_LOCAL_WHEELS={wheels_dir}")
+        if wheels_dir:
+            wheels_path = Path(wheels_dir)
+            self.log(f"  Wheels dir exists: {wheels_path.exists()}")
+            if wheels_path.exists():
+                local_wheels = list(wheels_path.glob("comfy_env-*.whl"))
+                self.log(f"  Found wheels: {[w.name for w in local_wheels]}")
+                if local_wheels:
+                    install_target = str(local_wheels[0])
+                    self.log(f"  Using local wheel: {local_wheels[0].name}")
+
         result = subprocess.run(
             [str(uv), "pip", "install", "--python", str(python_exe),
-             "--upgrade", "--no-cache",
-             "comfy-env @ git+https://github.com/PozzettiAndrea/comfy-env"],
+             "--upgrade", "--no-cache", install_target],
             capture_output=True,
             text=True,
         )

comfy_env/install.py

@@ -367,11 +367,25 @@ def _resolve_wheel_url(
 
         # wheel_template: direct URL
         if "wheel_template" in config:
+            template = config["wheel_template"]
+
+            # Only require version if template uses {version}
+            if "{version}" in template:
+                effective_version = version or config.get("default_version")
+                if not effective_version:
+                    raise InstallError(f"Package {package} requires version (no default in registry)")
+                vars_dict["version"] = effective_version
+
+            return _substitute_template(template, vars_dict)
+
+        # find_links: pip resolves wheel from index (e.g., miropsota's detectron2)
+        if "find_links" in config:
+            find_links_url = config["find_links"]
             effective_version = version or config.get("default_version")
-            if not effective_version:
-                raise InstallError(f"Package {package} requires version (no default in registry)")
-            vars_dict["version"] = effective_version
-            return _substitute_template(config["wheel_template"], vars_dict)
+            if effective_version:
+                return f"find_links:{find_links_url}:{package}=={effective_version}"
+            else:
+                return f"find_links:{find_links_url}:{package}"
 
         # package_name: PyPI variant (e.g., spconv-cu124)
         if "package_name" in config:
@@ -406,6 +420,11 @@ def _install_cuda_package(
         pkg_spec = f"{pkg_name}=={version}" if version else pkg_name
         log(f"  Installing {package} as {pkg_spec} from PyPI...")
         _pip_install([pkg_spec], no_deps=False, log=log)
+    elif url_or_marker.startswith("find_links:"):
+        # find_links: pip resolves from index URL
+        _, find_links_url, pkg_spec = url_or_marker.split(":", 2)
+        log(f"  Installing {pkg_spec} from {find_links_url}...")
+        _pip_install([pkg_spec, "--find-links", find_links_url], no_deps=True, log=log)
     else:
         # Direct wheel URL
         log(f"  Installing {package}...")

comfy_env/wheel_sources.yml

@@ -25,18 +25,22 @@ packages:
   # ===========================================================================
   torch-scatter:
     wheel_template: "https://data.pyg.org/whl/torch-{torch_version}%2Bcu{cuda_short}/torch_scatter-{version}%2Bpt{torch_mm}cu{cuda_short}-{py_tag}-{py_tag}-{platform}.whl"
+    default_version: "2.1.2"
     description: Scatter operations for PyTorch
 
   torch-cluster:
     wheel_template: "https://data.pyg.org/whl/torch-{torch_version}%2Bcu{cuda_short}/torch_cluster-{version}%2Bpt{torch_mm}cu{cuda_short}-{py_tag}-{py_tag}-{platform}.whl"
+    default_version: "1.6.3"
     description: Clustering algorithms for PyTorch
 
   torch-sparse:
     wheel_template: "https://data.pyg.org/whl/torch-{torch_version}%2Bcu{cuda_short}/torch_sparse-{version}%2Bpt{torch_mm}cu{cuda_short}-{py_tag}-{py_tag}-{platform}.whl"
+    default_version: "0.6.18"
     description: Sparse tensor operations for PyTorch
 
   torch-spline-conv:
     wheel_template: "https://data.pyg.org/whl/torch-{torch_version}%2Bcu{cuda_short}/torch_spline_conv-{version}%2Bpt{torch_mm}cu{cuda_short}-{py_tag}-{py_tag}-{platform}.whl"
+    default_version: "1.2.2"
     description: Spline convolutions for PyTorch
 
   # ===========================================================================
@@ -114,7 +118,8 @@ packages:
   # Prebuilt wheels from miropsota's torch_packages_builder
   # ===========================================================================
   detectron2:
-    wheel_template: "https://miropsota.github.io/torch_packages_builder/detectron2/detectron2-0.6%2B2a420edpt{torch_version}cu{cuda_short}-{py_tag}-{py_tag}-{platform}.whl"
+    find_links: "https://miropsota.github.io/torch_packages_builder/detectron2/"
+    default_version: "0.6"
     description: Detectron2 - Facebook's detection and segmentation library
 
   # ===========================================================================
@@ -131,5 +136,6 @@ packages:
   # Note: This uses a special package_name field, not wheel_template
   # ===========================================================================
   spconv:
-    package_name: "spconv-cu{cuda_short2}"
-    description: Sparse convolution library (installs spconv-cu124, spconv-cu126, etc.)
+    wheel_template: "https://github.com/PozzettiAndrea/cuda-wheels/releases/download/spconv_cu{cuda_short}-latest/spconv_cu{cuda_short}-{version}%2Bcu{cuda_short}torch{torch_mm}-{py_tag}-{py_tag}-{platform}.whl"
+    default_version: "2.3.8"
+    description: Sparse convolution library

comfy_env/workers/venv.py

@@ -29,6 +29,8 @@ Example:
 import json
 import os
 import shutil
+import socket
+import struct
 import subprocess
 import sys
 import tempfile
@@ -36,11 +38,154 @@ import threading
 import time
 import uuid
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from .base import Worker, WorkerError
 
 
+# =============================================================================
+# Socket IPC utilities - cross-platform with TCP fallback
+# =============================================================================
+
+def _has_af_unix() -> bool:
+    """Check if AF_UNIX sockets are available."""
+    return hasattr(socket, 'AF_UNIX')
+
+
+def _get_socket_dir() -> Path:
+    """Get directory for IPC sockets."""
+    if sys.platform == 'linux' and os.path.isdir('/dev/shm'):
+        return Path('/dev/shm')
+    elif sys.platform == 'win32':
+        return Path(tempfile.gettempdir())
+    else:
+        return Path(tempfile.gettempdir())
+
+
+def _create_server_socket() -> Tuple[socket.socket, str]:
+    """
+    Create a server socket for IPC.
+
+    Returns:
+        Tuple of (socket, address_string).
+        Address string is "unix://path" or "tcp://host:port".
+    """
+    if _has_af_unix():
+        # Unix domain socket (fast, no port conflicts)
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock_path = _get_socket_dir() / f"comfy_worker_{uuid.uuid4().hex[:12]}.sock"
+        # Remove stale socket file if exists
+        try:
+            sock_path.unlink()
+        except FileNotFoundError:
+            pass
+        sock.bind(str(sock_path))
+        sock.listen(1)
+        return sock, f"unix://{sock_path}"
+    else:
+        # TCP localhost fallback (works everywhere)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(('127.0.0.1', 0))  # OS picks free port
+        sock.listen(1)
+        port = sock.getsockname()[1]
+        return sock, f"tcp://127.0.0.1:{port}"
+
+
+def _connect_to_socket(addr: str) -> socket.socket:
+    """
+    Connect to a server socket.
+
+    Args:
+        addr: Address string ("unix://path" or "tcp://host:port").
+
+    Returns:
+        Connected socket.
+    """
+    if addr.startswith("unix://"):
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.connect(addr[7:])  # Strip "unix://"
+        return sock
+    elif addr.startswith("tcp://"):
+        host_port = addr[6:]  # Strip "tcp://"
+        host, port = host_port.rsplit(":", 1)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((host, int(port)))
+        return sock
+    else:
+        raise ValueError(f"Unknown socket address scheme: {addr}")
+
+
+class SocketTransport:
+    """
+    Length-prefixed JSON transport over sockets.
+
+    Message format: [4-byte big-endian length][JSON payload]
+    """
+
+    def __init__(self, sock: socket.socket):
+        self._sock = sock
+        self._send_lock = threading.Lock()
+        self._recv_lock = threading.Lock()
+
+    def send(self, obj: dict) -> None:
+        """Send a JSON-serializable object."""
+        data = json.dumps(obj).encode('utf-8')
+        msg = struct.pack('>I', len(data)) + data
+        with self._send_lock:
+            self._sock.sendall(msg)
+
+    def recv(self, timeout: Optional[float] = None) -> dict:
+        """Receive a JSON object. Returns None on timeout."""
+        with self._recv_lock:
+            if timeout is not None:
+                self._sock.settimeout(timeout)
+            try:
+                # Read 4-byte length header
+                raw_len = self._recvall(4)
+                if not raw_len:
+                    raise ConnectionError("Socket closed")
+                msg_len = struct.unpack('>I', raw_len)[0]
+
+                # Sanity check
+                if msg_len > 100 * 1024 * 1024:  # 100MB limit
+                    raise ValueError(f"Message too large: {msg_len} bytes")
+
+                # Read payload
+                data = self._recvall(msg_len)
+                if len(data) < msg_len:
+                    raise ConnectionError(f"Incomplete message: {len(data)}/{msg_len}")
+
+                return json.loads(data.decode('utf-8'))
+            except socket.timeout:
+                return None
+            finally:
+                if timeout is not None:
+                    self._sock.settimeout(None)
+
+    def _recvall(self, n: int) -> bytes:
+        """Receive exactly n bytes."""
+        data = bytearray()
+        while len(data) < n:
+            chunk = self._sock.recv(n - len(data))
+            if not chunk:
+                return bytes(data)
+            data.extend(chunk)
+        return bytes(data)
+
+    def close(self) -> None:
+        """Close the socket."""
+        try:
+            self._sock.close()
+        except:
+            pass
+
+
+# =============================================================================
+# Serialization helpers
+# =============================================================================
+
+
 def _serialize_for_ipc(obj, visited=None):
     """
     Convert objects with broken __module__ paths to dicts for IPC.
@@ -413,11 +558,13 @@ class VenvWorker(Worker):
 
 
 # Persistent worker script - runs as __main__ in the venv Python subprocess
-# Uses stdin/stdout JSON for IPC - avoids Windows multiprocessing spawn issues entirely
+# Uses Unix socket (or TCP localhost) for IPC - completely separate from stdout/stderr
 _PERSISTENT_WORKER_SCRIPT = '''
 import sys
 import os
 import json
+import socket
+import struct
 import traceback
 from types import SimpleNamespace
 
@@ -434,6 +581,57 @@ if sys.platform == "win32":
         except Exception:
             pass
 
+
+class SocketTransport:
+    """Length-prefixed JSON transport."""
+    def __init__(self, sock):
+        self._sock = sock
+
+    def send(self, obj):
+        data = json.dumps(obj).encode("utf-8")
+        msg = struct.pack(">I", len(data)) + data
+        self._sock.sendall(msg)
+
+    def recv(self):
+        raw_len = self._recvall(4)
+        if not raw_len:
+            return None
+        msg_len = struct.unpack(">I", raw_len)[0]
+        data = self._recvall(msg_len)
+        return json.loads(data.decode("utf-8"))
+
+    def _recvall(self, n):
+        data = bytearray()
+        while len(data) < n:
+            chunk = self._sock.recv(n - len(data))
+            if not chunk:
+                return bytes(data)
+            data.extend(chunk)
+        return bytes(data)
+
+    def close(self):
+        try:
+            self._sock.close()
+        except:
+            pass
+
+
+def _connect(addr):
+    """Connect to server socket (unix:// or tcp://)."""
+    if addr.startswith("unix://"):
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.connect(addr[7:])
+        return sock
+    elif addr.startswith("tcp://"):
+        host_port = addr[6:]
+        host, port = host_port.rsplit(":", 1)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((host, int(port)))
+        return sock
+    else:
+        raise ValueError(f"Unknown socket scheme: {addr}")
+
+
 def _deserialize_isolated_objects(obj):
     """Reconstruct objects serialized with __isolated_object__ marker."""
     if isinstance(obj, dict):
@@ -449,16 +647,22 @@ def _deserialize_isolated_objects(obj):
         return tuple(_deserialize_isolated_objects(v) for v in obj)
     return obj
 
-def main():
-    # Save original stdout for JSON IPC - redirect stdout to stderr for module prints
-    _ipc_out = sys.stdout
-    sys.stdout = sys.stderr  # All print() calls go to stderr now
 
-    # Read config from first line
-    config_line = sys.stdin.readline()
-    if not config_line:
+def main():
+    # 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]
+
+    # Connect to host process
+    sock = _connect(socket_addr)
+    transport = SocketTransport(sock)
+
+    # Read config as first message
+    config = transport.recv()
+    if not config:
         return
-    config = json.loads(config_line)
 
     # Setup sys.path
     for p in config.get("sys_paths", []):
@@ -468,17 +672,15 @@ def main():
     # Import torch after path setup
     import torch
 
-    # Signal ready (use _ipc_out, not stdout)
-    _ipc_out.write(json.dumps({"status": "ready"}) + "\\n")
-    _ipc_out.flush()
+    # Signal ready
+    transport.send({"status": "ready"})
 
     # Process requests
     while True:
         try:
-            line = sys.stdin.readline()
-            if not line:
+            request = transport.recv()
+            if not request:
                 break
-            request = json.loads(line)
         except Exception:
             break
 
@@ -521,16 +723,16 @@ def main():
             if outputs_path:
                 torch.save(result, outputs_path)
 
-            _ipc_out.write(json.dumps({"status": "ok"}) + "\\n")
-            _ipc_out.flush()
+            transport.send({"status": "ok"})
 
         except Exception as e:
-            _ipc_out.write(json.dumps({
+            transport.send({
                 "status": "error",
                 "error": str(e),
                 "traceback": traceback.format_exc(),
-            }) + "\\n")
-            _ipc_out.flush()
+            })
+
+    transport.close()
 
 if __name__ == "__main__":
     main()
@@ -541,15 +743,16 @@ class PersistentVenvWorker(Worker):
     """
     Persistent version of VenvWorker that keeps subprocess alive.
 
-    Uses subprocess.Popen with stdin/stdout JSON IPC instead of multiprocessing.
-    This avoids Windows multiprocessing spawn issues where the child process
-    tries to reimport __main__ (which fails when using a different Python).
+    Uses Unix domain sockets (or TCP localhost on older Windows) for IPC.
+    This completely separates IPC from stdout/stderr, so C libraries
+    printing to stdout (like Blender) won't corrupt the protocol.
 
     Benefits:
     - Works on Windows with different venv Python (full isolation)
     - Compiled CUDA extensions load correctly in the venv
     - ~50-100ms per call (vs ~300-500ms for VenvWorker per-call spawn)
     - Tensor transfer via shared memory files
+    - Immune to stdout pollution from C libraries
 
     Use this for high-frequency calls to isolated venvs.
     """
@@ -589,6 +792,11 @@ class PersistentVenvWorker(Worker):
         self._shutdown = False
         self._lock = threading.Lock()
 
+        # Socket IPC
+        self._server_socket: Optional[socket.socket] = None
+        self._socket_addr: Optional[str] = None
+        self._transport: Optional[SocketTransport] = None
+
         # Write worker script to temp file
         self._worker_script = self._temp_dir / "persistent_worker.py"
         self._worker_script.write_text(_PERSISTENT_WORKER_SCRIPT)
@@ -619,6 +827,17 @@ class PersistentVenvWorker(Worker):
         if self._process is not None and self._process.poll() is None:
             return  # Already running
 
+        # Clean up any previous socket
+        if self._transport:
+            self._transport.close()
+            self._transport = None
+        if self._server_socket:
+            self._server_socket.close()
+            self._server_socket = None
+
+        # Create server socket for IPC
+        self._server_socket, self._socket_addr = _create_server_socket()
+
         # Set up environment
         env = os.environ.copy()
         env.update(self.extra_env)
@@ -638,69 +857,55 @@ class PersistentVenvWorker(Worker):
         stubs_dir = Path(__file__).parent.parent / "stubs"
         all_sys_path = [str(stubs_dir), str(self.working_dir)] + self.sys_path
 
-        # Launch subprocess with the venv Python
-        # This runs _PERSISTENT_WORKER_SCRIPT as __main__ - no reimport issues!
+        # Launch subprocess with the venv Python, passing socket address
         self._process = subprocess.Popen(
-            [str(self.python), str(self._worker_script)],
-            stdin=subprocess.PIPE,
+            [str(self.python), str(self._worker_script), self._socket_addr],
+            stdin=subprocess.DEVNULL,
             stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+            stderr=subprocess.STDOUT,  # Merge stdout/stderr for forwarding
             cwd=str(self.working_dir),
             env=env,
-            bufsize=1,  # Line buffered
-            text=True,  # Text mode for JSON
         )
 
-        # Start stderr forwarding thread to show worker output in real-time
-        def forward_stderr():
+        # Start output forwarding thread
+        def forward_output():
             try:
-                for line in self._process.stderr:
-                    # Forward to main process stderr (visible in console)
+                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._stderr_thread = threading.Thread(target=forward_stderr, daemon=True)
-        self._stderr_thread.start()
+        self._output_thread = threading.Thread(target=forward_output, daemon=True)
+        self._output_thread.start()
 
-        # Send config
-        config = {"sys_paths": all_sys_path}
-        self._process.stdin.write(json.dumps(config) + "\n")
-        self._process.stdin.flush()
-
-        # Wait for ready signal with timeout
-        import select
-        if sys.platform == "win32":
-            # Windows: can't use select on pipes, use thread with timeout
-            ready_line = [None]
-            def read_ready():
-                try:
-                    ready_line[0] = self._process.stdout.readline()
-                except:
-                    pass
-            t = threading.Thread(target=read_ready, daemon=True)
-            t.start()
-            t.join(timeout=60)
-            line = ready_line[0]
-        else:
-            # Unix: use select for timeout
-            import select
-            ready, _, _ = select.select([self._process.stdout], [], [], 60)
-            line = self._process.stdout.readline() if ready else None
-
-        if not line:
+        # Accept connection from worker with timeout
+        self._server_socket.settimeout(60)
+        try:
+            client_sock, _ = self._server_socket.accept()
+        except socket.timeout:
             stderr = ""
             try:
                 self._process.kill()
-                _, stderr = self._process.communicate(timeout=5)
+                stdout, _ = self._process.communicate(timeout=5)
+                stderr = stdout.decode('utf-8', errors='replace') if stdout else ""
             except:
                 pass
-            raise RuntimeError(f"{self.name}: Worker failed to start (timeout). stderr: {stderr}")
+            raise RuntimeError(f"{self.name}: Worker failed to connect (timeout). output: {stderr}")
+        finally:
+            self._server_socket.settimeout(None)
 
-        try:
-            msg = json.loads(line)
-        except json.JSONDecodeError as e:
-            raise RuntimeError(f"{self.name}: Invalid ready message: {line!r}") from e
+        self._transport = SocketTransport(client_sock)
+
+        # Send config
+        config = {"sys_paths": all_sys_path}
+        self._transport.send(config)
+
+        # Wait for ready signal
+        msg = self._transport.recv(timeout=60)
+        if not msg:
+            raise RuntimeError(f"{self.name}: Worker failed to send ready signal")
 
         if msg.get("status") != "ready":
             raise RuntimeError(f"{self.name}: Unexpected ready message: {msg}")
@@ -718,31 +923,17 @@ class PersistentVenvWorker(Worker):
         )
 
     def _send_request(self, request: dict, timeout: float) -> dict:
-        """Send request via stdin and read response from stdout with timeout."""
+        """Send request via socket and read response with timeout."""
+        if not self._transport:
+            raise RuntimeError(f"{self.name}: Transport not initialized")
+
         # Send request
-        self._process.stdin.write(json.dumps(request) + "\n")
-        self._process.stdin.flush()
+        self._transport.send(request)
 
         # Read response with timeout
-        if sys.platform == "win32":
-            # Windows: use thread for timeout
-            response_line = [None]
-            def read_response():
-                try:
-                    response_line[0] = self._process.stdout.readline()
-                except:
-                    pass
-            t = threading.Thread(target=read_response, daemon=True)
-            t.start()
-            t.join(timeout=timeout)
-            line = response_line[0]
-        else:
-            # Unix: use select
-            import select
-            ready, _, _ = select.select([self._process.stdout], [], [], timeout)
-            line = self._process.stdout.readline() if ready else None
+        response = self._transport.recv(timeout=timeout)
 
-        if not line:
+        if response is None:
             # Timeout - kill process
             try:
                 self._process.kill()
@@ -751,10 +942,7 @@ class PersistentVenvWorker(Worker):
             self._shutdown = True
             raise TimeoutError(f"{self.name}: Call timed out after {timeout}s")
 
-        try:
-            return json.loads(line)
-        except json.JSONDecodeError as e:
-            raise WorkerError(f"Invalid response from worker: {line!r}") from e
+        return response
 
     def call_method(
         self,
@@ -882,16 +1070,33 @@ class PersistentVenvWorker(Worker):
             return
         self._shutdown = True
 
-        # Send shutdown signal via stdin
-        if self._process and self._process.poll() is None:
+        # Send shutdown signal via socket
+        if self._transport and self._process and self._process.poll() is None:
             try:
-                self._process.stdin.write(json.dumps({"method": "shutdown"}) + "\n")
-                self._process.stdin.flush()
-                self._process.stdin.close()
+                self._transport.send({"method": "shutdown"})
             except:
                 pass
 
-            # Wait for process to exit
+        # Close transport and socket
+        if self._transport:
+            self._transport.close()
+            self._transport = None
+
+        if self._server_socket:
+            try:
+                self._server_socket.close()
+            except:
+                pass
+            # Clean up unix socket file
+            if self._socket_addr and self._socket_addr.startswith("unix://"):
+                try:
+                    Path(self._socket_addr[7:]).unlink()
+                except:
+                    pass
+            self._server_socket = None
+
+        # Wait for process to exit
+        if self._process and self._process.poll() is None:
             try:
                 self._process.wait(timeout=5)
             except subprocess.TimeoutExpired:

{comfy_env-0.0.43.dist-info → comfy_env-0.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.43
+Version: 0.0.45
 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.43.dist-info → comfy_env-0.0.45.dist-info}/RECORD

@@ -2,7 +2,7 @@ comfy_env/__init__.py,sha256=OQJFNjmArjLcgrfHAFxgDJQFH_IhxibqMXbU5bu_j9Q,3822
 comfy_env/cli.py,sha256=hZv_oJsmaMoG62Fr2Fjp778P_32BHr4fzS7G4lULSwU,13153
 comfy_env/decorator.py,sha256=6JCKwLHaZtOLVDexs_gh_-NtS2ZK0V7nGCPqkyeYEAA,16688
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
-comfy_env/install.py,sha256=lKkW55mDLut3zpJOUgjAi-BdLluBRPN-bblONHjo-Ws,16595
+comfy_env/install.py,sha256=m4NKlfCcQGI5xzVRjHw3ep-lWbqx5kE1e21sUUZ2Leo,17528
 comfy_env/nodes.py,sha256=CWUe35jU5SKk4ur-SddZePdqWgxJDlxGhpcJiu5pAK4,4354
 comfy_env/pixi.py,sha256=y25mUDhB3bCqhPMGF0h23Tf8ZHykK4gLJrkvOhsPWmE,14398
 comfy_env/registry.py,sha256=w-QwvAPFlCrBYRAv4cXkp2zujQPZn8Fk5DUxKCtox8o,3430
@@ -11,7 +11,7 @@ comfy_env/env/__init__.py,sha256=imQdoQEQvrRT-QDtyNpFlkVbm2fBzgACdpQwRPd09fI,115
 comfy_env/env/config.py,sha256=Ila-5Yal3bj6jENbBeYJlZtkbgdwnzJzImVZK3ZF1lg,7645
 comfy_env/env/config_file.py,sha256=HzFKeQh9zQ--K1V-XuvgE6DiE_bYrXrChL1ZT8Tzlq4,24684
 comfy_env/env/cuda_gpu_detection.py,sha256=YLuXUdWg6FeKdNyLlQAHPlveg4rTenXJ2VbeAaEi9QE,9755
-comfy_env/env/manager.py,sha256=eDcrtJeNrW3jYb0q0R_DmUfAYjGo5Cs4BMuZUxWEzeg,21789
+comfy_env/env/manager.py,sha256=-qdbZDsbNfs70onVbC7mhKCzNsxYx3WmG7ttlBinhGI,23659
 comfy_env/env/security.py,sha256=dNSitAnfBNVdvxgBBntYw33AJaCs_S1MHb7KJhAVYzM,8171
 comfy_env/env/platform/__init__.py,sha256=Nb5MPZIEeanSMEWwqU4p4bnEKTJn1tWcwobnhq9x9IY,614
 comfy_env/env/platform/base.py,sha256=iS0ptTTVjXRwPU4qWUdvHI7jteuzxGSjWr5BUQ7hGiU,2453
@@ -35,10 +35,10 @@ comfy_env/workers/base.py,sha256=ZILYXlvGCWuCZXmjKqfG8VeD19ihdYaASdlbasl2BMo,231
 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=4YSNPn7hALrvMVbkO4RkTeFTcc0lhfLMk5QTWjY4PHw,22134
-comfy_env/workers/venv.py,sha256=PmsVOu5i89tBYkGRupo2bjOLPBmk06q4GNUwDWsd9F8,32088
-comfy_env/wheel_sources.yml,sha256=07-ruJ7HHGtXJUs7rDmud8X6OsBcfogZKG6cyU7Gacg,7950
-comfy_env-0.0.43.dist-info/METADATA,sha256=HzyWA3jqZjM9YsoFQEhZkHMTB8b8agepqMvo2YkOQY8,7138
-comfy_env-0.0.43.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.43.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.43.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.43.dist-info/RECORD,,
+comfy_env/workers/venv.py,sha256=YXIjSo4JSq2m9W2sDXA6N0pBc8kv_MpxfOJ2YZjBkw4,38219
+comfy_env/wheel_sources.yml,sha256=K5dksy21YcT7QdFlVDkKF4Rv9ZCjHaWhQgoEhdSyAOI,8156
+comfy_env-0.0.45.dist-info/METADATA,sha256=sVpd0ratFmnZ9CG2fN3-NP0CDrEscDwmlGpOPLCq2wk,7138
+comfy_env-0.0.45.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.45.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.45.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.45.dist-info/RECORD,,