execweave 0.8.12__tar.gz → 0.8.14__tar.gz

{execweave-0.8.12 → execweave-0.8.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.12
+Version: 0.8.14
 Summary: Turn AI-agent runtime behavior into a local interactive execution graph.
 Project-URL: Homepage, https://github.com/Irish-kw/ExecWeave
 Project-URL: Repository, https://github.com/Irish-kw/ExecWeave

{execweave-0.8.12 → execweave-0.8.14}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execweave"
-# ExecWeave v0.8.12 release metadata
-version = "0.8.12"
+# ExecWeave v0.8.14 release metadata
+version = "0.8.14"
 description = "Turn AI-agent runtime behavior into a local interactive execution graph."
 readme = "README.md"
 requires-python = ">=3.10"

{execweave-0.8.12 → execweave-0.8.14}/src/execweave/__init__.py

@@ -1,3 +1,3 @@
 """ExecWeave runtime graph package."""
 
-__version__ = "0.8.12"
+__version__ = "0.8.14"

{execweave-0.8.12 → execweave-0.8.14}/src/execweave/collector.py

@@ -123,12 +123,35 @@ class RuntimeCollector:
         self.collect_filesystem = collect_filesystem
         self.collect_network = collect_network
         self._seen_processes: dict[int, ProcessSnapshot] = {}
+        self._discovered_processes: dict[int, ProcessSnapshot] = {}
         self._seen_connections: set[tuple[str, str | None, str | None, str]] = set()
         self._network_sample_attempts = 0
         self._network_sample_successes = 0
         self._network_sample_errors = 0
         self._network_access_denied = 0
 
+    def _filesystem_excluded_roots(self) -> list[Path]:
+        """Return ExecWeave-owned paths that must never become workload evidence.
+
+        The default ``.execweave`` tree and the runtime event stream were already
+        internal. Live mode can also place ``events.jsonl`` and ``semantic.jsonl``
+        together in a caller-selected output directory inside the watch root. When
+        those files are siblings, exclude their whole run directory so ExecWeave's
+        own evidence writes cannot recursively manufacture filesystem evidence.
+        A separately configured semantic sidecar remains an exact-file exclusion.
+        """
+        sink_path = self.sink.path.expanduser().resolve()
+        excluded = [(self.watch_root / ".execweave").resolve(), sink_path]
+        configured = os.environ.get("EXECWEAVE_SEMANTIC_SIDECAR")
+        if not configured:
+            return excluded
+
+        semantic_path = Path(configured).expanduser().resolve()
+        excluded.append(
+            semantic_path.parent if semantic_path.parent == sink_path.parent else semantic_path
+        )
+        return excluded
+
     def run(self, command: list[str]) -> int:
         if not command:
             raise ValueError("command must not be empty")
@@ -163,17 +186,17 @@ class RuntimeCollector:
         )
 
         watcher: FileWatcher | None = None
-        internal_root = self.watch_root / ".execweave"
         if self.collect_filesystem:
             watcher = FileWatcher(
                 root=self.watch_root,
                 session_id=self.session_id,
                 session_entity=session,
                 sink=self.sink,
-                excluded_roots=[internal_root, self.sink.path],
+                excluded_roots=self._filesystem_excluded_roots(),
             )
 
         process: subprocess.Popen[bytes] | None = None
+        owned: list[psutil.Process] = []
         return_code = 1
         interrupted = False
         collector_error_type: str | None = None
@@ -209,8 +232,6 @@ class RuntimeCollector:
             except KeyboardInterrupt:
                 interrupted = True
                 return_code = 130
-                if process is not None:
-                    self._terminate_process_tree(process)
 
             if not interrupted:
                 run_post_command_specialized_probe(
@@ -220,16 +241,24 @@ class RuntimeCollector:
             return return_code
         except BaseException as exc:
             collector_error_type = type(exc).__name__
-            if process is not None and process.poll() is None:
-                self._terminate_process_tree(process)
-                workload_terminated_due_to_collector_error = True
             raise
         finally:
+            # A workload exception is a nonzero child exit, not an exception in
+            # this collector. Finalize observed descendants on every exit path,
+            # including successful launchers that leave reparented children.
+            if process is not None:
+                owned = self._owned_live_processes(process)
+                workload_terminated_due_to_collector_error = (
+                    collector_error_type is not None and bool(owned)
+                )
+                self._terminate_process_tree(process, owned=owned)
             if watcher is not None:
                 watcher.stop()
-            workload_alive_after_cleanup = bool(
-                process is not None and process.poll() is None
-            )
+            # A failed termination must not become a false clean result merely
+            # because the selected child has since reparented out of the tree.
+            workload_alive_after_cleanup = any(
+                self._process_is_live(candidate) for candidate in owned
+            ) or bool(process is not None and self._owned_live_processes(process))
             self.sink.emit(
                 RuntimeEvent.create(
                     session_id=self.session_id,
@@ -258,33 +287,95 @@ class RuntimeCollector:
             )
 
     @staticmethod
-    def _terminate_process_tree(process: subprocess.Popen[bytes]) -> None:
-        descendants: list[psutil.Process] = []
+    def _process_is_live(proc: psutil.Process) -> bool:
+        try:
+            if not proc.is_running():
+                return False
+            try:
+                return proc.status() != psutil.STATUS_ZOMBIE
+            except psutil.AccessDenied:
+                return True
+        except (psutil.NoSuchProcess, psutil.ZombieProcess):
+            return False
+
+    def _process_for_snapshot(self, snapshot: ProcessSnapshot) -> psutil.Process | None:
         try:
-            root = psutil.Process(process.pid)
-            descendants = root.children(recursive=True)
+            process = psutil.Process(snapshot.pid)
+            # Cleanup needs identity, not readable exe/name/cmdline metadata.
+            # Never treat a reused PID as the process we originally observed.
+            if process.create_time() != snapshot.create_time:
+                return None
+            return process
         except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            pass
+            return None
 
-        for child in reversed(descendants):
+    def _owned_live_processes(
+        self,
+        process: subprocess.Popen[bytes],
+    ) -> list[psutil.Process]:
+        """Return live processes still owned by this collector's launched workload.
+
+        A shell or launcher can exit before its children. Relying only on the current
+        root process tree then loses those reparented descendants. The collector's
+        lifetime-qualified process snapshots preserve enough ownership evidence to
+        find and clean them without risking a reused PID.
+        """
+        owned: dict[int, psutil.Process] = {}
+
+        def add_with_descendants(candidate: psutil.Process) -> None:
+            if not self._process_is_live(candidate):
+                return
+            owned[candidate.pid] = candidate
             try:
-                child.terminate()
+                descendants = candidate.children(recursive=True)
             except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                pass
+                descendants = []
+            for child in descendants:
+                if self._process_is_live(child):
+                    owned[child.pid] = child
 
         if process.poll() is None:
             try:
-                process.terminate()
-            except OSError:
+                add_with_descendants(psutil.Process(process.pid))
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                pass
+
+        snapshots = {**self._seen_processes, **self._discovered_processes}
+        for snapshot in snapshots.values():
+            tracked = self._process_for_snapshot(snapshot)
+            if tracked is not None:
+                add_with_descendants(tracked)
+
+        return list(owned.values())
+
+    def _terminate_process_tree(
+        self,
+        process: subprocess.Popen[bytes],
+        *,
+        owned: list[psutil.Process] | None = None,
+    ) -> None:
+        # A caller's selection must survive reparenting between discovery and
+        # termination. Re-querying here can lose children we just proved owned.
+        if owned is None:
+            owned = self._owned_live_processes(process)
+        # Terminate descendants/tracked orphans before the launcher/root when it is
+        # still alive. Holding psutil handles also keeps cleanup robust if a parent
+        # exits while the loop is running.
+        for candidate in sorted(owned, key=lambda item: item.pid == process.pid):
+            try:
+                candidate.terminate()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                 pass
 
-        if descendants:
-            _, alive = psutil.wait_procs(descendants, timeout=2.0)
-            for child in alive:
+        if owned:
+            _, alive = psutil.wait_procs(owned, timeout=2.0)
+            for candidate in alive:
                 try:
-                    child.kill()
+                    candidate.kill()
                 except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                     pass
+            if alive:
+                psutil.wait_procs(alive, timeout=2.0)
 
         try:
             process.wait(timeout=2.0)
@@ -319,6 +410,11 @@ class RuntimeCollector:
             current[snapshot.pid] = snapshot
             process_objects[snapshot.pid] = proc
 
+        # Preserve the complete discovered tree before any event/network callback
+        # can raise. _seen_processes only contains successfully registered starts;
+        # a root callback can fail after its children have already reparented.
+        # Retain only the latest sample here, not an unbounded lifetime history.
+        self._discovered_processes = current
         for snapshot in current.values():
             previous = self._seen_processes.get(snapshot.pid)
             if previous is None or not self._same_process_lifetime(previous, snapshot):

{execweave-0.8.12 → execweave-0.8.14}/src/execweave/command.py

@@ -80,7 +80,12 @@ def _resolve_executable(executable: str, *, path: str | None = None) -> str:
         candidate = Path(executable).expanduser()
         if not candidate.is_file():
             raise FileNotFoundError(f"command executable not found: {executable!r}")
-        resolved = str(candidate.resolve())
+        # Keep the user-selected launcher path itself. In particular, a virtualenv
+        # Python executable is commonly a symlink to the base interpreter on POSIX;
+        # dereferencing it changes Python's prefix discovery and silently drops the
+        # virtualenv site-packages. ``abspath`` normalizes the argv path without
+        # resolving symlinks.
+        resolved = os.path.abspath(os.fspath(candidate))
     else:
         path_launcher = shutil.which(executable, path=path)
         if executable.lower() == "cursor" and _prefer_cursor_desktop_launcher():

execweave-0.8.14/tests/test_pypi_0812_regressions.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import time
+import venv
+from pathlib import Path
+
+import psutil
+import pytest
+
+from execweave.collector import RuntimeCollector, _safe_process_snapshot
+from execweave.command import resolve_launch_command
+from execweave.sink import JsonlSink
+
+
+def _process_is_live(pid: int) -> bool:
+    try:
+        process = psutil.Process(pid)
+        return process.is_running() and process.status() != psutil.STATUS_ZOMBIE
+    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+        return False
+
+
+def _wait_for(predicate, *, timeout: float = 5.0) -> None:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if predicate():
+            return
+        time.sleep(0.02)
+    raise AssertionError("condition did not become true before timeout")
+
+
+def test_explicit_virtualenv_python_keeps_launcher_and_site_prefix(tmp_path: Path) -> None:
+    venv_root = tmp_path / ".venv"
+    venv.EnvBuilder(with_pip=False, symlinks=os.name != "nt").create(venv_root)
+    venv_python = (
+        venv_root / "Scripts" / "python.exe"
+        if os.name == "nt"
+        else venv_root / "bin" / "python"
+    )
+    if os.name != "nt":
+        assert venv_python.is_symlink()
+
+    launch = resolve_launch_command(
+        [str(venv_python), "-c", "import sys; print(sys.prefix)"]
+    )
+
+    assert launch[0] == os.path.abspath(os.fspath(venv_python))
+    if os.name != "nt":
+        assert Path(launch[0]).is_symlink()
+    completed = subprocess.run(
+        launch,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    assert Path(completed.stdout.strip()).resolve() == venv_root.resolve()
+
+
+def test_live_sibling_sidecar_excludes_entire_internal_output_dir(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    run_dir = tmp_path / "custom-live-output"
+    run_dir.mkdir()
+    event_path = run_dir / "events.jsonl"
+    semantic_path = run_dir / "semantic.jsonl"
+    monkeypatch.setenv("EXECWEAVE_SEMANTIC_SIDECAR", str(semantic_path))
+
+    collector = RuntimeCollector(
+        session_id="d001",
+        sink=JsonlSink(event_path),
+        watch_root=tmp_path,
+        poll_interval=0.02,
+        collect_filesystem=True,
+        collect_network=False,
+    )
+
+    excluded = collector._filesystem_excluded_roots()
+    assert run_dir.resolve() in excluded
+    assert event_path.resolve() in excluded
+
+
+def test_separate_semantic_sidecar_does_not_hide_unrelated_parent_directory(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    run_dir = tmp_path / "runtime-output"
+    sidecar_dir = tmp_path / "user-selected-sidecar-dir"
+    run_dir.mkdir()
+    sidecar_dir.mkdir()
+    semantic_path = sidecar_dir / "semantic.jsonl"
+    monkeypatch.setenv("EXECWEAVE_SEMANTIC_SIDECAR", str(semantic_path))
+
+    collector = RuntimeCollector(
+        session_id="d001-separate",
+        sink=JsonlSink(run_dir / "events.jsonl"),
+        watch_root=tmp_path,
+        poll_interval=0.02,
+        collect_filesystem=True,
+        collect_network=False,
+    )
+
+    excluded = collector._filesystem_excluded_roots()
+    assert semantic_path.resolve() in excluded
+    assert sidecar_dir.resolve() not in excluded
+
+
+def test_cleanup_terminates_tracked_child_after_launcher_has_exited(tmp_path: Path) -> None:
+    child_pid_path = tmp_path / "child.pid"
+    release_parent_path = tmp_path / "release-parent"
+    parent_code = r'''
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+pid_path = Path(sys.argv[1])
+release_path = Path(sys.argv[2])
+child = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(30)"])
+pid_path.write_text(str(child.pid), encoding="utf-8")
+while not release_path.exists():
+    time.sleep(0.02)
+'''
+    parent = subprocess.Popen(
+        [
+            sys.executable,
+            "-c",
+            parent_code,
+            str(child_pid_path),
+            str(release_parent_path),
+        ]
+    )
+    child_pid: int | None = None
+    try:
+        _wait_for(child_pid_path.exists)
+        child_pid = int(child_pid_path.read_text(encoding="utf-8"))
+        child = psutil.Process(child_pid)
+        snapshot = _safe_process_snapshot(child)
+        assert snapshot is not None
+
+        collector = RuntimeCollector(
+            session_id="d003",
+            sink=JsonlSink(tmp_path / "events.jsonl"),
+            watch_root=tmp_path,
+            poll_interval=0.02,
+            collect_filesystem=False,
+            collect_network=False,
+        )
+        collector._seen_processes[child_pid] = snapshot
+
+        release_parent_path.touch()
+        parent.wait(timeout=5)
+        assert parent.poll() is not None
+        assert _process_is_live(child_pid)
+
+        collector._terminate_process_tree(parent)
+
+        _wait_for(lambda: not _process_is_live(child_pid))
+        assert not _process_is_live(child_pid)
+    finally:
+        if parent.poll() is None:
+            parent.kill()
+            parent.wait(timeout=5)
+        if child_pid is not None and _process_is_live(child_pid):
+            try:
+                psutil.Process(child_pid).kill()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                pass