cross-platform: replace os.kill/fcntl with psutil/filelock; fix Windows encoding

Source changes:
- restart_daemon.py: replace fcntl.flock with filelock.FileLock (cross-platform),
  replace os.kill(pid, 15/9) with psutil.Process.terminate/kill
- ai_monitor.py: replace os.kill(pid, 0) with psutil.pid_exists,
  replace os.kill(pid, SIGTERM) with psutil.Process.terminate
- client.py: replace os.kill(pid, 0) with psutil.pid_exists
- install.py: replace os.kill(pid, 0) with psutil.pid_exists

Test changes:
- test_daemon_restart_safety.py: replace placeholder tests with real
  filelock RAII, thread safety, multiprocess exclusion, and psutil
  lifecycle tests (11 tests, 10 run in CI)
- All 17 test files: add encoding="utf-8" to .read_text() calls to
  fix Windows UnicodeDecodeError (cp1252 default codec)

Author: ahundt

plugins/autorun/src/autorun/ai_monitor.py

@@ -21,6 +21,8 @@
 import signal
 import logging
 from pathlib import Path
+
+import psutil
 from contextlib import contextmanager
 
 # Import centralized tmux utilities for DRY compliance
@@ -108,10 +110,12 @@ def start_monitor(session_id, prompt="Continue working", stop_marker=None, max_c
     pf = Path(f"/tmp/ai-monitor-{session_id}.pid")
     if pf.exists():
         try:
-            os.kill(int(pf.read_text()), 0)
-            return int(pf.read_text())  # Already running
-        except (OSError, ValueError):
+            pid = int(pf.read_text())
+            if psutil.pid_exists(pid):
+                return pid  # Already running
             pf.unlink()
+        except (OSError, ValueError):
+            pf.unlink(missing_ok=True)
 
     # Spawn monitor as subprocess
     script = Path(__file__)
@@ -128,21 +132,23 @@ def stop_monitor(session_id):
     pf = Path(f"/tmp/ai-monitor-{session_id}.pid")
     if pf.exists():
         try:
-            os.kill(int(pf.read_text()), signal.SIGTERM)
+            proc = psutil.Process(int(pf.read_text()))
+            proc.terminate()
             pf.unlink()
-        except (OSError, ValueError):
-            pass
+        except (psutil.NoSuchProcess, psutil.AccessDenied, OSError, ValueError):
+            pf.unlink(missing_ok=True)
 
 def check_monitor(session_id):
     """Check if monitor is running, return PID or None"""
     pf = Path(f"/tmp/ai-monitor-{session_id}.pid")
     if pf.exists():
         try:
             pid = int(pf.read_text())
-            os.kill(pid, 0)
-            return pid
-        except (OSError, ValueError):
+            if psutil.pid_exists(pid):
+                return pid
             pf.unlink()
+        except (OSError, ValueError):
+            pf.unlink(missing_ok=True)
     return None
 
 # Core monitor loop

plugins/autorun/src/autorun/client.py

@@ -268,8 +268,8 @@ async def forward(depth: int = 0):
             if lock_path.exists():
                 try:
                     pid = int(lock_path.read_text().strip())
-                    os.kill(pid, 0)  # Check if process is alive (signal 0)
-                    daemon_alive = True
+                    import psutil
+                    daemon_alive = psutil.pid_exists(pid)
                 except (ValueError, ProcessLookupError, PermissionError):
                     # PID invalid or process dead — safe to spawn new daemon
                     lock_path.unlink(missing_ok=True)

plugins/autorun/src/autorun/install.py

@@ -162,8 +162,10 @@ def _restart_daemon_if_running() -> None:
     if not lock_path.exists():
         return
     try:
+        import psutil
         pid = int(lock_path.read_text().strip())
-        os.kill(pid, 0)
+        if not psutil.pid_exists(pid):
+            return
     except (ValueError, OSError):
         return
 

plugins/autorun/src/autorun/restart_daemon.py

@@ -23,12 +23,11 @@
 import time
 import socket
 import subprocess
-import fcntl
-import errno
 from contextlib import contextmanager
 from pathlib import Path
 
 import psutil
+from filelock import FileLock, Timeout
 
 HOME_DIR = Path.home() / ".autorun"
 SOCKET_PATH = HOME_DIR / "daemon.sock"
@@ -43,7 +42,8 @@ def get_daemon_pid() -> int | None:
     try:
         pid = int(LOCK_PATH.read_text().strip())
         # Verify process actually exists (not just a stale lock file)
-        os.kill(pid, 0)
+        if not psutil.pid_exists(pid):
+            return None
         return pid
     except (ValueError, OSError):
         return None
@@ -111,56 +111,33 @@ def verify_bashlex() -> bool:
         return False
 
 
-def acquire_restart_lock():
-    """Acquire exclusive restart lock to prevent concurrent restarts.
-
-    Returns:
-        file descriptor if lock acquired, None otherwise
-
-    Prefer restart_lock() context manager for RAII-safe usage.
-    """
-    try:
-        lock_fd = open(RESTART_LOCK_PATH, 'w')
-        fcntl.flock(lock_fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-        lock_fd.write(f"{os.getpid()}\n")
-        lock_fd.flush()
-        return lock_fd
-    except (IOError, OSError) as e:
-        if hasattr(e, 'errno') and e.errno == errno.EAGAIN:
-            return None  # Another restart in progress
-        raise
-
-
-def release_restart_lock(lock_fd) -> None:
-    """Release restart lock and cleanup lock file."""
-    if lock_fd:
-        try:
-            fcntl.flock(lock_fd.fileno(), fcntl.LOCK_UN)
-            lock_fd.close()
-        except (IOError, OSError):
-            pass
-        try:
-            RESTART_LOCK_PATH.unlink()
-        except OSError:
-            pass
-
-
 @contextmanager
 def restart_lock():
     """Context manager for the restart lock. Yields True if acquired, False otherwise.
 
+    Uses filelock for cross-platform file locking (works on Unix and Windows).
+    RAII: lock is only released if it was successfully acquired.
+
     Usage:
         with restart_lock() as acquired:
             if not acquired:
                 print("Another restart in progress")
                 return
             # ... do restart work ...
     """
-    lock_fd = acquire_restart_lock()
+    lock = FileLock(str(RESTART_LOCK_PATH), timeout=0)
+    acquired = False
     try:
-        yield lock_fd is not None
+        lock.acquire()
+        acquired = True
+    except Timeout:
+        pass
+
+    try:
+        yield acquired
     finally:
-        release_restart_lock(lock_fd)
+        if acquired:
+            lock.release()
 
 
 def _resolve_src_dir() -> Path | None:
@@ -325,7 +302,11 @@ def _stop_daemon(pid: int) -> None:
     4. If clean but stale files remain: cleanup
     """
     print(f"  Sending SIGTERM to PID {pid}")
-    os.kill(pid, 15)  # SIGTERM
+    try:
+        proc = psutil.Process(pid)
+        proc.terminate()  # SIGTERM on Unix, TerminateProcess on Windows
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        pass
 
     # Wait for FULL shutdown (PID gone AND socket closed)
     shutdown_clean = wait_for_shutdown(max_wait=5.0)
@@ -334,9 +315,10 @@ def _stop_daemon(pid: int) -> None:
         # Daemon didn't shut down cleanly - force it
         print("  ⚠️ Timeout, forcing shutdown")
         try:
-            os.kill(pid, 9)  # SIGKILL
+            proc = psutil.Process(pid)
+            proc.kill()  # SIGKILL on Unix, TerminateProcess on Windows
             time.sleep(0.5)
-        except OSError:
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
             pass
         # Only cleanup stale files if daemon failed to clean up
         cleanup_stale_files()

plugins/autorun/tests/test_bootstrap_config.py

@@ -169,7 +169,7 @@ def test_disable_bootstrap_adds_flag(self, temp_hooks_dir):
 
         # Verify hooks.json was modified
         hooks_file = Path(temp_hooks_dir) / "hooks" / "claude-hooks.json"
-        content = hooks_file.read_text()
+        content = hooks_file.read_text(encoding="utf-8")
 
         # All commands should now have --no-bootstrap
         assert "--no-bootstrap" in content
@@ -186,7 +186,7 @@ def test_enable_bootstrap_removes_flag(self, temp_hooks_dir_disabled):
 
         # Verify hooks.json was modified
         hooks_file = Path(temp_hooks_dir_disabled) / "hooks" / "claude-hooks.json"
-        content = hooks_file.read_text()
+        content = hooks_file.read_text(encoding="utf-8")
 
         # No commands should have --no-bootstrap
         assert "--no-bootstrap" not in content
@@ -232,13 +232,13 @@ def test_disable_preserves_json_structure(self, temp_hooks_dir):
         from autorun.__main__ import set_bootstrap_config
 
         hooks_file = Path(temp_hooks_dir) / "hooks" / "claude-hooks.json"
-        original_data = json.loads(hooks_file.read_text())
+        original_data = json.loads(hooks_file.read_text(encoding="utf-8"))
 
         with mock.patch.dict(os.environ, {"CLAUDE_PLUGIN_ROOT": temp_hooks_dir}):
             set_bootstrap_config(enabled=False)
 
         # Verify JSON is still valid
-        modified_content = hooks_file.read_text()
+        modified_content = hooks_file.read_text(encoding="utf-8")
         modified_data = json.loads(modified_content)
 
         # Structure should be preserved
@@ -415,7 +415,7 @@ def test_no_bootstrap_calls_set_bootstrap_config_false(self, temp_hooks_dir):
 
         # Verify flag was added
         hooks_file = Path(temp_hooks_dir) / "hooks" / "claude-hooks.json"
-        assert "--no-bootstrap" in hooks_file.read_text()
+        assert "--no-bootstrap" in hooks_file.read_text(encoding="utf-8")
 
     def test_enable_bootstrap_calls_set_bootstrap_config_true(
         self, temp_hooks_dir_disabled
@@ -432,7 +432,7 @@ def test_enable_bootstrap_calls_set_bootstrap_config_true(
 
         # Verify flag was removed
         hooks_file = Path(temp_hooks_dir_disabled) / "hooks" / "claude-hooks.json"
-        assert "--no-bootstrap" not in hooks_file.read_text()
+        assert "--no-bootstrap" not in hooks_file.read_text(encoding="utf-8")
 
     def test_version_returns_zero(self, capsys):
         """Test that --version returns exit code 0."""

plugins/autorun/tests/test_claude_e2e_real_money.py

@@ -734,7 +734,7 @@ def test_plan_export_posttooluse_exitplanmode_writes_to_notes(
             )
 
             # Verify exported content matches our plan
-            exported_content = exported[0].read_text()
+            exported_content = exported[0].read_text(encoding="utf-8")
             assert unique_marker in exported_content or "E2E Test Plan" in exported_content, (
                 f"Exported file does not contain expected plan content.\n"
                 f"Exported file: {exported[0]}\n"