execweave 0.8.12__tar.gz → 0.8.13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.12
+Version: 0.8.13
 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.13}/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.13 release metadata
+version = "0.8.13"
 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.13}/src/execweave/__init__.py

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

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

@@ -129,6 +129,28 @@ class RuntimeCollector:
         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,14 +185,13 @@ 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
@@ -220,7 +241,7 @@ 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:
+            if process is not None and self._owned_live_processes(process):
                 self._terminate_process_tree(process)
                 workload_terminated_due_to_collector_error = True
             raise
@@ -228,7 +249,7 @@ class RuntimeCollector:
             if watcher is not None:
                 watcher.stop()
             workload_alive_after_cleanup = bool(
-                process is not None and process.poll() is None
+                process is not None and self._owned_live_processes(process)
             )
             self.sink.emit(
                 RuntimeEvent.create(
@@ -258,33 +279,85 @@ 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:
-            root = psutil.Process(process.pid)
-            descendants = root.children(recursive=True)
+            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:
+            process = psutil.Process(snapshot.pid)
         except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            pass
+            return None
+        current = _safe_process_snapshot(process)
+        if current is None or not self._same_process_lifetime(snapshot, current):
+            return None
+        return process
+
+    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:
+                descendants = candidate.children(recursive=True)
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                descendants = []
+            for child in descendants:
+                if self._process_is_live(child):
+                    owned[child.pid] = child
 
-        for child in reversed(descendants):
+        if process.poll() is None:
             try:
-                child.terminate()
+                add_with_descendants(psutil.Process(process.pid))
             except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                 pass
 
-        if process.poll() is None:
+        for snapshot in list(self._seen_processes.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]) -> 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:
-                process.terminate()
-            except OSError:
+                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)

{execweave-0.8.12 → execweave-0.8.13}/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.13/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

{execweave-0.8.12 → execweave-0.8.13}/tests/test_v069_dashboard_release.py

@@ -103,10 +103,10 @@ def test_release_version_and_noncommercial_license_metadata_are_078() -> None:
     stage-integrity node-ID floor refuses renames; the assertions below are the
     current release.
     """
-    assert __version__ == "0.8.12"
+    assert __version__ == "0.8.13"
     pyproject = Path("pyproject.toml").read_text(encoding="utf-8")
-    assert 'version = "0.8.12"' in pyproject
-    assert "ExecWeave v0.8.12 release metadata" in pyproject
+    assert 'version = "0.8.13"' in pyproject
+    assert "ExecWeave v0.8.13 release metadata" in pyproject
     assert "License :: Other/Proprietary License" in pyproject
     assert "License :: OSI Approved :: MIT License" not in pyproject