codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/core/runner_controller.py

@@ -1,40 +1,41 @@
-from __future__ import annotations
-
 import threading
-from collections.abc import Callable
+from typing import Callable, Optional
 
-from .engine import Engine, LockError
 from .locks import DEFAULT_RUNNER_CMD_HINTS, assess_lock, process_alive, read_lock_info
 from .runner_process import build_runner_cmd, spawn_detached
+from .runtime import LockError, RuntimeContext
 from .state import RunnerState, load_state, now_iso, save_state, state_lock
 
-SpawnRunnerFn = Callable[[list[str], Engine], object]
+SpawnRunnerFn = Callable[[list[str], RuntimeContext], object]
 
 
-def _spawn_detached(cmd: list[str], engine: Engine) -> object:
-    return spawn_detached(cmd, cwd=engine.repo_root)
+def _spawn_detached(cmd: list[str], ctx: RuntimeContext) -> object:
+    return spawn_detached(cmd, cwd=ctx.repo_root)
 
 
 class ProcessRunnerController:
-    def __init__(self, engine: Engine, *, spawn_fn: SpawnRunnerFn | None = None):
-        self.engine = engine
+    def __init__(
+        self, ctx: RuntimeContext, *, spawn_fn: Optional[SpawnRunnerFn] = None
+    ):
+        self.ctx = ctx
         self._spawn_fn = spawn_fn or _spawn_detached
         self._lock = threading.Lock()
 
     @property
     def running(self) -> bool:
-        return self.engine.runner_pid() is not None
+        return self.ctx.runner_pid() is not None
 
     def reconcile(self) -> None:
         lock_pid = None
-        if self.engine.lock_path.exists():
-            info = read_lock_info(self.engine.lock_path)
+        if self.ctx.lock_path.exists():
+            info = read_lock_info(self.ctx.lock_path)
             lock_pid = info.pid if info.pid and process_alive(info.pid) else None
             if not lock_pid:
-                self.engine.lock_path.unlink(missing_ok=True)
+                self.ctx.lock_path.unlink(missing_ok=True)
 
-        with state_lock(self.engine.state_path):
-            state = load_state(self.engine.state_path)
+        durable = self.ctx.config.durable_writes
+        with state_lock(self.ctx.state_path):
+            state = load_state(self.ctx.state_path, durable=durable)
             if lock_pid:
                 if state.runner_pid != lock_pid or state.status != "running":
                     new_state = RunnerState(
@@ -53,8 +54,8 @@ class ProcessRunnerController:
                         sessions=state.sessions,
                         repo_to_session=state.repo_to_session,
                     )
-                    save_state(self.engine.state_path, new_state)
-                self.engine.reconcile_run_index()
+                    save_state(self.ctx.state_path, new_state, durable=durable)
+                self.ctx.reconcile_run_index()
                 return
 
             pid = state.runner_pid
@@ -84,17 +85,17 @@ class ProcessRunnerController:
                     sessions=state.sessions,
                     repo_to_session=state.repo_to_session,
                 )
-                save_state(self.engine.state_path, new_state)
+                save_state(self.ctx.state_path, new_state, durable=durable)
 
-        self.engine.reconcile_run_index()
+        self.ctx.reconcile_run_index()
 
     def _ensure_unlocked(self) -> None:
-        if not self.engine.lock_path.exists():
+        if not self.ctx.lock_path.exists():
             return
         assessment = self._clear_freeable_lock()
         if assessment.freeable:
             return
-        info = read_lock_info(self.engine.lock_path)
+        info = read_lock_info(self.ctx.lock_path)
         pid = info.pid
         if pid and process_alive(pid):
             raise LockError(
@@ -104,14 +105,15 @@ class ProcessRunnerController:
 
     def _clear_freeable_lock(self):
         assessment = assess_lock(
-            self.engine.lock_path,
+            self.ctx.lock_path,
             expected_cmd_substrings=DEFAULT_RUNNER_CMD_HINTS,
         )
         if not assessment.freeable:
             return assessment
-        self.engine.lock_path.unlink(missing_ok=True)
-        with state_lock(self.engine.state_path):
-            state = load_state(self.engine.state_path)
+        self.ctx.lock_path.unlink(missing_ok=True)
+        durable = self.ctx.config.durable_writes
+        with state_lock(self.ctx.state_path):
+            state = load_state(self.ctx.state_path, durable=durable)
             if state.status == "running" or state.runner_pid:
                 exit_code = state.last_exit_code
                 if exit_code is None:
@@ -132,7 +134,7 @@ class ProcessRunnerController:
                     sessions=state.sessions,
                     repo_to_session=state.repo_to_session,
                 )
-                save_state(self.engine.state_path, new_state)
+                save_state(self.ctx.state_path, new_state, durable=durable)
         return assessment
 
     def clear_freeable_lock(self):
@@ -141,17 +143,17 @@ class ProcessRunnerController:
 
     def _spawn_runner(self, *, action: str, once: bool = False) -> None:
         cmd = build_runner_cmd(
-            self.engine.repo_root,
+            self.ctx.repo_root,
             action=action,
             once=once,
         )
-        self._spawn_fn(cmd, self.engine)
+        self._spawn_fn(cmd, self.ctx)
 
     def start(self, once: bool = False) -> None:
         with self._lock:
             self.reconcile()
             self._ensure_unlocked()
-            self.engine.clear_stop_request()
+            self.ctx.clear_stop_request()
             action = "once" if once else "run"
             self._spawn_runner(action=action)
 
@@ -159,13 +161,13 @@ class ProcessRunnerController:
         with self._lock:
             self.reconcile()
             self._ensure_unlocked()
-            self.engine.clear_stop_request()
+            self.ctx.clear_stop_request()
             self._spawn_runner(action="resume", once=once)
 
     def stop(self) -> None:
         with self._lock:
-            self.engine.request_stop()
+            self.ctx.request_stop()
 
-    def kill(self) -> int | None:
+    def kill(self) -> Optional[int]:
         with self._lock:
-            return self.engine.kill_running_process()
+            return self.ctx.kill_running_process()

codex_autorunner/core/runner_state.py

@@ -0,0 +1,147 @@
+"""Runner state and lock management utilities.
+
+This module provides runner state operations extracted from Engine.
+"""
+
+import os
+import signal
+from pathlib import Path
+from typing import Optional
+
+from .locks import (
+    DEFAULT_RUNNER_CMD_HINTS,
+    FileLock,
+    FileLockBusy,
+    assess_lock,
+    process_alive,
+    read_lock_info,
+    write_lock_info,
+)
+from .state import load_state, now_iso
+
+
+class LockError(Exception):
+    """Raised when a runner lock cannot be acquired."""
+
+
+def _timestamp() -> str:
+    return now_iso()
+
+
+class RunnerStateManager:
+    """Manages runner state and locks for ticket flows."""
+
+    def __init__(
+        self,
+        repo_root: Path,
+        lock_path: Optional[Path] = None,
+        state_path: Optional[Path] = None,
+    ):
+        self.repo_root = repo_root
+        self.lock_path = lock_path or (repo_root / ".codex-autorunner" / "lock")
+        self.state_path = state_path or (
+            repo_root / ".codex-autorunner" / "state.sqlite3"
+        )
+        self.stop_path = repo_root / ".codex-autorunner" / "stop"
+        self._lock_handle: Optional[FileLock] = None
+
+    def acquire_lock(self, force: bool = False) -> None:
+        """Acquire the runner lock."""
+        self._lock_handle = FileLock(self.lock_path)
+        try:
+            self._lock_handle.acquire(blocking=False)
+        except FileLockBusy as exc:
+            info = read_lock_info(self.lock_path)
+            pid = info.pid
+            if pid and process_alive(pid):
+                raise LockError(
+                    f"Another autorunner is active (pid={pid}); stop it before continuing"
+                ) from exc
+            raise LockError(
+                "Another autorunner is active; stop it before continuing"
+            ) from exc
+
+        info = read_lock_info(self.lock_path)
+        pid = info.pid
+        if pid and process_alive(pid) and not force:
+            self._lock_handle.release()
+            self._lock_handle = None
+            raise LockError(
+                f"Another autorunner is active (pid={pid}); use --force to override"
+            )
+        write_lock_info(
+            self.lock_path,
+            os.getpid(),
+            started_at=_timestamp(),
+            lock_file=self._lock_handle.file,
+        )
+
+    def release_lock(self) -> None:
+        """Release the runner lock."""
+        if self._lock_handle is not None:
+            self._lock_handle.release()
+            self._lock_handle = None
+        if self.lock_path.exists():
+            self.lock_path.unlink()
+
+    def repo_busy_reason(self) -> Optional[str]:
+        """Return a reason why the repo is busy, or None if not busy."""
+        if self.lock_path.exists():
+            assessment = assess_lock(
+                self.lock_path,
+                expected_cmd_substrings=DEFAULT_RUNNER_CMD_HINTS,
+            )
+            if assessment.freeable:
+                return "Autorunner lock is stale; clear it before continuing."
+            pid = assessment.pid
+            if pid and process_alive(pid):
+                host = f" on {assessment.host}" if assessment.host else ""
+                return f"Autorunner is running (pid={pid}{host}); try again later."
+            return "Autorunner lock present; clear or resume before continuing."
+
+        state = load_state(self.state_path)
+        if state.status == "running":
+            if state.runner_pid and process_alive(state.runner_pid):
+                return f"Autorunner is currently running (pid={state.runner_pid}); try again later."
+            return "Autorunner state is stale; use 'car resume' to continue."
+        return None
+
+    def request_stop(self) -> None:
+        """Request a stop by writing to the stop path."""
+        self.stop_path.parent.mkdir(parents=True, exist_ok=True)
+        self.stop_path.write_text(f"{_timestamp()}\n")
+
+    def clear_stop_request(self) -> None:
+        """Clear a stop request."""
+        self.stop_path.unlink(missing_ok=True)
+
+    def stop_requested(self) -> bool:
+        """Check if a stop has been requested."""
+        return self.stop_path.exists()
+
+    def kill_running_process(self) -> Optional[int]:
+        """Force-kill the process holding the lock, if any. Returns pid if killed."""
+        if not self.lock_path.exists():
+            return None
+        info = read_lock_info(self.lock_path)
+        pid = info.pid
+        if pid and process_alive(pid):
+            try:
+                os.kill(pid, signal.SIGTERM)
+                return pid
+            except OSError:
+                return None
+        # stale lock
+        self.lock_path.unlink(missing_ok=True)
+        return None
+
+    def runner_pid(self) -> Optional[int]:
+        """Get the PID of the running runner."""
+        state = load_state(self.state_path)
+        pid = state.runner_pid
+        if pid and process_alive(pid):
+            return pid
+        info = read_lock_info(self.lock_path)
+        if info.pid and process_alive(info.pid):
+            return info.pid
+        return None