agentirc-cli 1.0.6__tar.gz → 1.0.7__tar.gz

{agentirc_cli-1.0.6 → agentirc_cli-1.0.7}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [1.0.7] - 2026-04-05
+
+
+### Fixed
+
+- Validate PID ownership via /proc/<pid>/cmdline before os.kill() to prevent signaling unrelated processes after PID reuse (SonarCloud S4828)
+- Wrap initial SIGTERM in try/except ProcessLookupError for race condition safety
+
 ## [1.0.6] - 2026-04-05
 
 

{agentirc_cli-1.0.6 → agentirc_cli-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 1.0.6
+Version: 1.0.7
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum

{agentirc_cli-1.0.6 → agentirc_cli-1.0.7}/culture/cli.py

@@ -38,7 +38,13 @@ from culture.clients.claude.config import (
     load_config_or_default,
     sanitize_agent_name,
 )
-from culture.pidfile import is_process_alive, read_pid, remove_pid, write_pid
+from culture.pidfile import (
+    is_culture_process,
+    is_process_alive,
+    read_pid,
+    remove_pid,
+    write_pid,
+)
 
 logger = logging.getLogger("culture")
 
@@ -902,13 +908,27 @@ def _try_pid_shutdown(nick: str) -> None:
         print(f"No PID file for agent '{nick}'")
         return
 
+    if pid <= 0:
+        print(f"Invalid PID {pid} for agent '{nick}' — removing corrupt PID file")
+        remove_pid(pid_name)
+        return
+
     if not is_process_alive(pid):
         print(f"Agent '{nick}' is not running (stale PID {pid})")
         remove_pid(pid_name)
         return
 
+    if not is_culture_process(pid):
+        print(f"PID {pid} is not a culture process — removing stale PID file")
+        remove_pid(pid_name)
+        return
+
     print(f"Stopping agent '{nick}' (PID {pid})...")
-    os.kill(pid, signal.SIGTERM)
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        remove_pid(pid_name)
+        return
 
     for _ in range(50):
         if not is_process_alive(pid):
@@ -917,6 +937,13 @@ def _try_pid_shutdown(nick: str) -> None:
             return
         time.sleep(0.1)
 
+    # Re-validate ownership before escalating — the original process may have
+    # exited and the PID may have been reused during the 5s wait.
+    if not is_culture_process(pid):
+        print(f"PID {pid} is no longer a culture process — aborting kill")
+        remove_pid(pid_name)
+        return
+
     # Force kill
     if sys.platform == "win32":
         print(f"Agent '{nick}' did not stop gracefully, terminating")

{agentirc_cli-1.0.6 → agentirc_cli-1.0.7}/culture/pidfile.py

@@ -72,6 +72,27 @@ def remove_port(name: str) -> None:
         pass
 
 
+def is_culture_process(pid: int) -> bool:
+    """Check whether the given PID belongs to a culture process.
+
+    Reads /proc/<pid>/cmdline on Linux and checks NUL-separated argv
+    tokens for an exact "culture" match (e.g. argv[0] basename or a
+    ``-m culture`` argument).  On platforms without /proc, returns True
+    (assumes valid).  On Linux, read/parse failures return False (fail
+    closed) to avoid killing unrelated processes after PID reuse.
+    """
+    if not os.path.isdir("/proc"):
+        # /proc not available (macOS / Windows) — can't verify, assume valid
+        return True
+    try:
+        raw = Path(f"/proc/{pid}/cmdline").read_bytes()
+        tokens = [t for t in raw.decode(errors="replace").split("\x00") if t]
+        return any(os.path.basename(t) == "culture" or t == "culture" for t in tokens)
+    except (OSError, PermissionError):
+        # On Linux /proc exists but we can't read this PID — fail closed
+        return False
+
+
 def is_process_alive(pid: int) -> bool:
     """Check whether a process with the given PID is alive."""
     try:

{agentirc_cli-1.0.6 → agentirc_cli-1.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentirc-cli"
-version = "1.0.6"
+version = "1.0.7"
 description = "Legacy alias for culture — install culture instead"
 readme = "README.md"
 license = "MIT"

agentirc_cli-1.0.7/tests/test_pidfile.py

@@ -0,0 +1,122 @@
+"""Tests for culture.pidfile — PID file management and process validation."""
+
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from culture.pidfile import (
+    is_culture_process,
+    is_process_alive,
+    read_pid,
+    remove_pid,
+    write_pid,
+)
+
+
+@pytest.fixture()
+def pid_dir(tmp_path):
+    """Use a temporary directory for PID files."""
+    with patch("culture.pidfile.PID_DIR", str(tmp_path)):
+        yield tmp_path
+
+
+class TestWriteReadRemove:
+    def test_write_and_read(self, pid_dir):
+        write_pid("agent-bot", 12345)
+        assert read_pid("agent-bot") == 12345
+
+    def test_read_missing(self, pid_dir):
+        assert read_pid("nonexistent") is None
+
+    def test_remove(self, pid_dir):
+        write_pid("agent-bot", 12345)
+        remove_pid("agent-bot")
+        assert read_pid("agent-bot") is None
+
+    def test_remove_missing_is_noop(self, pid_dir):
+        remove_pid("nonexistent")  # should not raise
+
+
+class TestIsProcessAlive:
+    def test_current_process_alive(self):
+        assert is_process_alive(os.getpid()) is True
+
+    def test_nonexistent_pid(self):
+        # Use a very high PID unlikely to exist.
+        assert is_process_alive(4_000_000) is False
+
+
+class TestIsCultureProcess:
+    @pytest.mark.skipif(
+        not Path("/proc/self/cmdline").exists(),
+        reason="/proc not available",
+    )
+    def test_current_process_is_python(self):
+        # We're running under pytest — cmdline won't contain "culture"
+        # as an exact argv token, so this should return False.
+        result = is_culture_process(os.getpid())
+        assert isinstance(result, bool)
+
+    def test_cmdline_with_culture_token(self):
+        """Exact argv token 'culture' is recognized (e.g. -m culture)."""
+        raw = b"/usr/bin/python3\x00-m\x00culture\x00start\x00"
+        with (
+            patch("culture.pidfile.Path") as mock_path,
+            patch("culture.pidfile.os.path.isdir", return_value=True),
+        ):
+            mock_path.return_value.read_bytes.return_value = raw
+            assert is_culture_process(999) is True
+
+    def test_cmdline_with_culture_basename(self):
+        """argv[0] with basename 'culture' is recognized."""
+        raw = b"/home/user/.local/bin/culture\x00server\x00start\x00"
+        with (
+            patch("culture.pidfile.Path") as mock_path,
+            patch("culture.pidfile.os.path.isdir", return_value=True),
+        ):
+            mock_path.return_value.read_bytes.return_value = raw
+            assert is_culture_process(999) is True
+
+    def test_cmdline_without_culture(self):
+        """Process with unrelated cmdline is rejected."""
+        raw = b"/sbin/init\x00--system\x00"
+        with (
+            patch("culture.pidfile.Path") as mock_path,
+            patch("culture.pidfile.os.path.isdir", return_value=True),
+        ):
+            mock_path.return_value.read_bytes.return_value = raw
+            assert is_culture_process(999) is False
+
+    def test_cmdline_substring_not_matched(self):
+        """Substring 'culture' inside another token is NOT matched."""
+        raw = b"/usr/bin/agriculture-daemon\x00--flag\x00"
+        with (
+            patch("culture.pidfile.Path") as mock_path,
+            patch("culture.pidfile.os.path.isdir", return_value=True),
+        ):
+            mock_path.return_value.read_bytes.return_value = raw
+            assert is_culture_process(999) is False
+
+    def test_no_proc_returns_true(self):
+        """When /proc doesn't exist (macOS/Windows), assume valid."""
+        with patch("culture.pidfile.os.path.isdir", return_value=False):
+            assert is_culture_process(999) is True
+
+    def test_oserror_on_linux_returns_false(self):
+        """On Linux, read failures fail closed (return False)."""
+        with (
+            patch("culture.pidfile.Path") as mock_path,
+            patch("culture.pidfile.os.path.isdir", return_value=True),
+        ):
+            mock_path.return_value.read_bytes.side_effect = OSError("denied")
+            assert is_culture_process(999) is False
+
+    @pytest.mark.skipif(
+        not Path("/proc/self/cmdline").exists(),
+        reason="/proc not available",
+    )
+    def test_nonexistent_pid_fails_closed(self):
+        """/proc exists but PID doesn't — should return False."""
+        assert is_culture_process(4_000_000) is False

{agentirc_cli-1.0.6 → agentirc_cli-1.0.7}/uv.lock

@@ -561,7 +561,7 @@ wheels = [
 
 [[package]]
 name = "culture"
-version = "1.0.6"
+version = "1.0.7"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },