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

codex_autorunner/core/flows/worker_process.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import IO, Literal, Optional, Tuple
+
+_WORKER_METADATA_FILENAME = "worker.json"
+
+
+@dataclass
+class FlowWorkerHealth:
+    status: Literal["absent", "alive", "dead", "invalid", "mismatch"]
+    pid: Optional[int]
+    cmdline: list[str]
+    artifact_path: Path
+    message: Optional[str] = None
+
+    @property
+    def is_alive(self) -> bool:
+        return self.status == "alive"
+
+
+def _normalized_run_id(run_id: str) -> str:
+    return str(uuid.UUID(str(run_id)))
+
+
+def _worker_artifacts_dir(
+    repo_root: Path, run_id: str, artifacts_root: Optional[Path] = None
+) -> Path:
+    repo_root = repo_root.resolve()
+    base_artifacts = (
+        artifacts_root
+        if artifacts_root is not None
+        else repo_root / ".codex-autorunner" / "flows"
+    )
+    artifacts_dir = base_artifacts / _normalized_run_id(run_id)
+    artifacts_dir.mkdir(parents=True, exist_ok=True)
+    return artifacts_dir
+
+
+def _worker_metadata_path(artifacts_dir: Path) -> Path:
+    return artifacts_dir / _WORKER_METADATA_FILENAME
+
+
+def _build_worker_cmd(entrypoint: str, run_id: str) -> list[str]:
+    normalized_run_id = _normalized_run_id(run_id)
+    return [
+        sys.executable,
+        "-m",
+        entrypoint,
+        "flow",
+        "worker",
+        "--run-id",
+        normalized_run_id,
+    ]
+
+
+def _pid_is_running(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        # Process exists but we may not own it.
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def _read_process_cmdline(pid: int) -> list[str] | None:
+    proc_path = Path(f"/proc/{pid}/cmdline")
+    if proc_path.exists():
+        try:
+            raw = proc_path.read_bytes()
+            return [part for part in raw.decode().split("\0") if part]
+        except Exception:
+            pass
+
+    try:
+        out = subprocess.check_output(
+            ["ps", "-p", str(pid), "-o", "command="],
+            stderr=subprocess.DEVNULL,
+        )
+        cmd = out.decode().strip()
+        if cmd:
+            return cmd.split()
+    except Exception:
+        return None
+    return None
+
+
+def _cmdline_matches(expected: list[str], actual: list[str]) -> bool:
+    if not expected or not actual:
+        return False
+    if len(actual) >= len(expected) and actual[-len(expected) :] == expected:
+        return True
+    expected_str = " ".join(expected)
+    actual_str = " ".join(actual)
+    return expected_str in actual_str
+
+
+def _write_worker_metadata(path: Path, pid: int, cmd: list[str]) -> None:
+    data = {
+        "pid": pid,
+        "cmd": cmd,
+        "cwd": os.getcwd(),
+    }
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    # Also emit a plain PID file for quick inspection.
+    pid_path = path.with_suffix(".pid")
+    pid_path.write_text(str(pid), encoding="utf-8")
+
+
+def clear_worker_metadata(artifacts_dir: Path) -> None:
+    for name in (
+        _WORKER_METADATA_FILENAME,
+        f"{Path(_WORKER_METADATA_FILENAME).stem}.pid",
+    ):
+        try:
+            (artifacts_dir / name).unlink()
+        except FileNotFoundError:
+            pass
+        except Exception:
+            pass
+
+
+def check_worker_health(
+    repo_root: Path,
+    run_id: str,
+    *,
+    artifacts_root: Optional[Path] = None,
+    entrypoint: str = "codex_autorunner",
+) -> FlowWorkerHealth:
+    artifacts_dir = _worker_artifacts_dir(repo_root, run_id, artifacts_root)
+    metadata_path = _worker_metadata_path(artifacts_dir)
+
+    if not metadata_path.exists():
+        return FlowWorkerHealth(
+            status="absent",
+            pid=None,
+            cmdline=[],
+            artifact_path=metadata_path,
+            message="worker metadata missing",
+        )
+
+    try:
+        data = json.loads(metadata_path.read_text(encoding="utf-8"))
+        pid = int(data.get("pid")) if data.get("pid") is not None else None
+        cmd = data.get("cmd") or []
+    except Exception:
+        return FlowWorkerHealth(
+            status="invalid",
+            pid=None,
+            cmdline=[],
+            artifact_path=metadata_path,
+            message="worker metadata unreadable",
+        )
+
+    if not pid or pid <= 0:
+        return FlowWorkerHealth(
+            status="invalid",
+            pid=pid,
+            cmdline=cmd if isinstance(cmd, list) else [],
+            artifact_path=metadata_path,
+            message="missing or invalid PID",
+        )
+
+    if not _pid_is_running(pid):
+        return FlowWorkerHealth(
+            status="dead",
+            pid=pid,
+            cmdline=cmd if isinstance(cmd, list) else [],
+            artifact_path=metadata_path,
+            message="worker PID not running",
+        )
+
+    expected_cmd = _build_worker_cmd(entrypoint, run_id)
+    actual_cmd = _read_process_cmdline(pid)
+    if actual_cmd is None:
+        # Can't inspect cmdline; trust the PID check.
+        return FlowWorkerHealth(
+            status="alive",
+            pid=pid,
+            cmdline=cmd if isinstance(cmd, list) else [],
+            artifact_path=metadata_path,
+            message="worker running (cmdline unknown)",
+        )
+
+    if not _cmdline_matches(expected_cmd, actual_cmd):
+        return FlowWorkerHealth(
+            status="mismatch",
+            pid=pid,
+            cmdline=actual_cmd,
+            artifact_path=metadata_path,
+            message="worker PID command does not match expected",
+        )
+
+    return FlowWorkerHealth(
+        status="alive",
+        pid=pid,
+        cmdline=actual_cmd,
+        artifact_path=metadata_path,
+        message="worker running",
+    )
+
+
+def spawn_flow_worker(
+    repo_root: Path,
+    run_id: str,
+    *,
+    artifacts_root: Optional[Path] = None,
+    entrypoint: str = "codex_autorunner",
+) -> Tuple[subprocess.Popen, IO[bytes], IO[bytes]]:
+    """Spawn a detached flow worker with consistent artifacts/log layout."""
+
+    normalized_run_id = _normalized_run_id(run_id)
+    repo_root = repo_root.resolve()
+    artifacts_dir = _worker_artifacts_dir(repo_root, normalized_run_id, artifacts_root)
+
+    stdout_path = artifacts_dir / "worker.out.log"
+    stderr_path = artifacts_dir / "worker.err.log"
+
+    stdout_handle = stdout_path.open("ab")
+    stderr_handle = stderr_path.open("ab")
+
+    cmd = _build_worker_cmd(entrypoint, normalized_run_id)
+
+    proc = subprocess.Popen(
+        cmd,
+        cwd=repo_root,
+        stdout=stdout_handle,
+        stderr=stderr_handle,
+    )
+
+    _write_worker_metadata(_worker_metadata_path(artifacts_dir), proc.pid, cmd)
+    return proc, stdout_handle, stderr_handle

codex_autorunner/core/hub.py

@@ -26,7 +26,7 @@ from .git_utils import (
     git_upstream_status,
     run_git,
 )
-from .locks import process_alive, read_lock_info
+from .locks import DEFAULT_RUNNER_CMD_HINTS, assess_lock, process_alive
 from .runner_controller import ProcessRunnerController, SpawnRunnerFn
 from .state import RunnerState, load_state, now_iso
 from .utils import atomic_write
@@ -120,9 +120,11 @@ class HubState:
 def read_lock_status(lock_path: Path) -> LockStatus:
     if not lock_path.exists():
         return LockStatus.UNLOCKED
-    info = read_lock_info(lock_path)
-    pid = info.pid
-    if pid and process_alive(pid):
+    assessment = assess_lock(
+        lock_path,
+        expected_cmd_substrings=DEFAULT_RUNNER_CMD_HINTS,
+    )
+    if not assessment.freeable and assessment.pid and process_alive(assessment.pid):
         return LockStatus.LOCKED_ALIVE
     return LockStatus.LOCKED_STALE
 
@@ -135,7 +137,8 @@ def load_hub_state(state_path: Path, hub_root: Path) -> HubState:
         import json
 
         payload = json.loads(data)
-    except Exception:
+    except Exception as exc:
+        logger.warning("Failed to parse hub state from %s: %s", state_path, exc)
         return HubState(last_scan_at=None, repos=[])
     last_scan_at = payload.get("last_scan_at")
     repos_payload = payload.get("repos") or []
@@ -166,7 +169,13 @@ def load_hub_state(state_path: Path, hub_root: Path) -> HubState:
                 runner_pid=entry.get("runner_pid"),
             )
             repos.append(repo)
-        except Exception:
+        except Exception as exc:
+            repo_id = entry.get("id", "unknown")
+            logger.warning(
+                "Failed to load repo snapshot for id=%s from hub state: %s",
+                repo_id,
+                exc,
+            )
             continue
     return HubState(last_scan_at=last_scan_at, repos=repos)
 
@@ -757,10 +766,10 @@ class HubSupervisor:
         if not repo:
             raise ValueError(f"Repo {repo_id} not found in manifest")
         repo_root = (self.hub_config.root / repo.path).resolve()
-        state_path = repo_root / ".codex-autorunner" / "state.json"
-        if not allow_uninitialized and not state_path.exists():
+        tickets_dir = repo_root / ".codex-autorunner" / "tickets"
+        if not allow_uninitialized and not tickets_dir.exists():
             raise ValueError(f"Repo {repo_id} is not initialized")
-        if not state_path.exists():
+        if not tickets_dir.exists():
             return None
         repo_config = derive_repo_config(self.hub_config, repo_root, load_env=False)
         runner = RepoRunner(
@@ -779,7 +788,7 @@ class HubSupervisor:
         records: List[DiscoveryRecord] = []
         for entry in manifest.repos:
             repo_path = (self.hub_config.root / entry.path).resolve()
-            initialized = (repo_path / ".codex-autorunner" / "state.json").exists()
+            initialized = (repo_path / ".codex-autorunner" / "tickets").exists()
             records.append(
                 DiscoveryRecord(
                     repo=entry,
@@ -819,9 +828,8 @@ class HubSupervisor:
         lock_status = read_lock_status(lock_path)
 
         runner_state: Optional[RunnerState] = None
-        state_path = repo_path / ".codex-autorunner" / "state.json"
-        if record.initialized and state_path.exists():
-            runner_state = load_state(state_path)
+        if record.initialized:
+            runner_state = load_state(repo_path / ".codex-autorunner" / "state.sqlite3")
 
         is_clean: Optional[bool] = None
         if record.exists_on_disk and git_available(repo_path):

codex_autorunner/core/locks.py

@@ -1,11 +1,13 @@
 import errno
 import json
+import logging
 import os
 import socket
+import subprocess
 from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import IO, Iterator, Optional
+from typing import IO, Iterable, Iterator, Optional
 
 from .utils import atomic_write
 
@@ -17,6 +19,18 @@ class LockInfo:
     host: Optional[str]
 
 
+@dataclass
+class LockAssessment:
+    freeable: bool
+    reason: Optional[str]
+    pid: Optional[int]
+    host: Optional[str]
+
+
+DEFAULT_RUNNER_CMD_HINTS = ("codex_autorunner.cli", "codex-autorunner", "car ")
+logger = logging.getLogger(__name__)
+
+
 def process_alive(pid: int) -> bool:
     try:
         os.kill(pid, 0)
@@ -25,6 +39,109 @@ def process_alive(pid: int) -> bool:
     return True
 
 
+def process_is_zombie(pid: int) -> bool:
+    if os.name == "nt":
+        return False
+    try:
+        result = subprocess.run(
+            ["ps", "-o", "stat=", "-p", str(pid)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except Exception:
+        logger.debug("Failed to check process status for pid %s", pid, exc_info=True)
+        return False
+    if result.returncode != 0:
+        return False
+    return "Z" in result.stdout.strip()
+
+
+def process_command(pid: int) -> Optional[str]:
+    if os.name == "nt":
+        return None
+    try:
+        result = subprocess.run(
+            ["ps", "-o", "command=", "-p", str(pid)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except Exception:
+        logger.debug("Failed to inspect process command for pid %s", pid, exc_info=True)
+        return None
+    if result.returncode != 0:
+        return None
+    command = result.stdout.strip()
+    return command or None
+
+
+def process_is_active(pid: int) -> bool:
+    return process_alive(pid) and not process_is_zombie(pid)
+
+
+def assess_lock(
+    lock_path: Path,
+    *,
+    expected_cmd_substrings: Optional[Iterable[str]] = None,
+    require_host_match: bool = True,
+) -> LockAssessment:
+    if not lock_path.exists():
+        return LockAssessment(freeable=False, reason=None, pid=None, host=None)
+    info = read_lock_info(lock_path)
+    pid = info.pid
+    if not pid:
+        return LockAssessment(
+            freeable=True,
+            reason="Lock has no pid; safe to clear.",
+            pid=None,
+            host=info.host,
+        )
+    if not process_alive(pid):
+        return LockAssessment(
+            freeable=True,
+            reason="Lock pid is not running; safe to clear.",
+            pid=pid,
+            host=info.host,
+        )
+    if process_is_zombie(pid):
+        return LockAssessment(
+            freeable=True,
+            reason="Lock pid is a zombie process; safe to clear.",
+            pid=pid,
+            host=info.host,
+        )
+    if require_host_match and info.host and info.host != socket.gethostname():
+        return LockAssessment(
+            freeable=False,
+            reason="Lock belongs to another host.",
+            pid=pid,
+            host=info.host,
+        )
+    if expected_cmd_substrings:
+        command = process_command(pid)
+        if command is None:
+            return LockAssessment(
+                freeable=False,
+                reason="Unable to inspect lock pid command.",
+                pid=pid,
+                host=info.host,
+            )
+        if not any(fragment in command for fragment in expected_cmd_substrings):
+            return LockAssessment(
+                freeable=True,
+                reason="Lock pid command does not match autorunner; safe to clear.",
+                pid=pid,
+                host=info.host,
+            )
+    return LockAssessment(
+        freeable=False,
+        reason=None,
+        pid=pid,
+        host=info.host,
+    )
+
+
 try:
     import fcntl
 except ImportError:  # pragma: no cover - Windows fallback

codex_autorunner/core/logging_utils.py

@@ -8,6 +8,8 @@ from typing import Any, Mapping, Optional, OrderedDict
 from .config import LogConfig
 from .request_context import get_conversation_id, get_request_id
 
+logger = logging.getLogger("codex_autorunner.core.logging_utils")
+
 _MAX_CACHED_LOGGERS = 64
 _LOGGER_CACHE: "OrderedDict[str, logging.Logger]" = collections.OrderedDict()
 _REDACTED_VALUE = "<redacted>"
@@ -60,10 +62,10 @@ def setup_rotating_logger(name: str, log_config: LogConfig) -> logging.Logger:
             for h in list(evicted.handlers):
                 try:
                     h.close()
-                except Exception:
+                except (OSError, ValueError):
                     pass
             evicted.handlers.clear()
-        except Exception:
+        except (OSError, ValueError, RuntimeError):
             pass
     return logger
 
@@ -74,18 +76,19 @@ def safe_log(
     message: str,
     *args,
     exc: Optional[Exception] = None,
+    exc_info: bool = False,
 ) -> None:
     try:
         formatted = message
         if args:
             try:
                 formatted = message % args
-            except Exception:
+            except (TypeError, ValueError):
                 formatted = f"{message} {' '.join(str(arg) for arg in args)}"
         if exc is not None:
             formatted = f"{formatted}: {exc}"
-        logger.log(level, formatted)
-    except Exception:
+        logger.log(level, formatted, exc_info=exc_info)
+    except (OSError, TypeError, ValueError, RuntimeError):
         pass
 
 
@@ -114,7 +117,7 @@ def log_event(
     try:
         message = json.dumps(payload, ensure_ascii=True, separators=(",", ":"))
         logger.log(level, message)
-    except Exception:
+    except (TypeError, ValueError, OverflowError, RuntimeError):
         pass
 
 

codex_autorunner/core/path_utils.py

@@ -0,0 +1,123 @@
+from pathlib import Path
+from typing import Optional, Union
+
+PathLike = Union[str, Path]
+
+
+class ConfigPathError(Exception):
+    """Raised when a config path is invalid."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        path: Optional[str] = None,
+        resolved: Optional[Path] = None,
+        scope: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.path = path
+        self.resolved = resolved
+        self.scope = scope
+
+    def __str__(self) -> str:
+        msg = super().__str__()
+        if self.scope:
+            msg = f"{self.scope}: {msg}"
+        if self.path:
+            msg = f"{msg} (path: {self.path})"
+        if self.resolved:
+            msg = f"{msg} (resolved: {self.resolved})"
+        return msg
+
+
+def resolve_config_path(
+    value: PathLike,
+    repo_root: Path,
+    *,
+    allow_absolute: bool = False,
+    allow_home: bool = False,
+    allow_dotdot: bool = False,
+    scope: Optional[str] = None,
+) -> Path:
+    """
+    Resolve a config path according to standard rules.
+
+    Rules:
+    1. If value starts with '/' and allow_absolute=True, use as-is
+    2. If value starts with '~', expand to home directory
+    3. Otherwise, resolve relative to repo_root
+    4. Reject '..' segments unless allow_dotdot=True
+    5. Reject paths escaping repo_root (except home expansion)
+
+    Args:
+        value: Path string or Path object
+        repo_root: Repository root directory
+        allow_absolute: Allow absolute paths (default False)
+        allow_home: Allow home directory expansion with ~ (default False)
+        allow_dotdot: Allow '..' segments (default False, for security)
+        scope: Config section name for error messages (e.g., 'docs.todo')
+
+    Returns:
+        Resolved Path object
+
+    Raises:
+        ConfigPathError: If path is invalid
+    """
+    value_str = str(value)
+
+    if not value_str:
+        raise ConfigPathError("Path cannot be empty", path=value_str, scope=scope)
+
+    if value_str.strip() == "":
+        raise ConfigPathError(
+            "Path cannot be whitespace only", path=value_str, scope=scope
+        )
+
+    value_str = value_str.strip()
+
+    path = Path(value_str)
+
+    if path.is_absolute():
+        if allow_absolute:
+            return path.resolve()
+        raise ConfigPathError(
+            "Absolute paths are not allowed",
+            path=value_str,
+            scope=scope,
+        )
+
+    if str(path).startswith("~"):
+        if not allow_home:
+            raise ConfigPathError(
+                "Home directory expansion (~) is not allowed",
+                path=value_str,
+                scope=scope,
+            )
+        if not allow_dotdot and ".." in path.parts:
+            raise ConfigPathError(
+                "Path contains '..' segments",
+                path=value_str,
+                scope=scope,
+            )
+        resolved = path.expanduser().resolve()
+        return resolved
+
+    if not allow_dotdot and ".." in path.parts:
+        raise ConfigPathError(
+            "Path contains '..' segments",
+            path=value_str,
+            scope=scope,
+        )
+
+    resolved = (repo_root / path).resolve()
+
+    if not allow_home and not allow_dotdot and not resolved.is_relative_to(repo_root):
+        raise ConfigPathError(
+            "Path resolves outside repo root",
+            path=value_str,
+            resolved=resolved,
+            scope=scope,
+        )
+
+    return resolved

codex_autorunner/core/prompt.py

@@ -15,12 +15,20 @@ def _display_path(root: Path, path: Path) -> str:
 
 
 def build_doc_paths(config: Config) -> Mapping[str, str]:
+    def _safe_path(*keys: str) -> str:
+        for key in keys:
+            try:
+                return _display_path(config.root, config.doc_path(key))
+            except KeyError:
+                continue
+        return ""
+
     return {
-        "todo": _display_path(config.root, config.doc_path("todo")),
-        "progress": _display_path(config.root, config.doc_path("progress")),
-        "opinions": _display_path(config.root, config.doc_path("opinions")),
-        "spec": _display_path(config.root, config.doc_path("spec")),
-        "summary": _display_path(config.root, config.doc_path("summary")),
+        "todo": _safe_path("todo", "active_context"),
+        "progress": _safe_path("progress", "decisions"),
+        "opinions": _safe_path("opinions"),
+        "spec": _safe_path("spec"),
+        "summary": _safe_path("summary"),
     }
 
 
@@ -64,8 +72,8 @@ def build_final_summary_prompt(
 
     doc_paths = build_doc_paths(config)
     doc_contents = {
-        "todo": docs.read_doc("todo"),
-        "progress": docs.read_doc("progress"),
+        "todo": docs.read_doc("todo") or docs.read_doc("active_context"),
+        "progress": docs.read_doc("progress") or docs.read_doc("decisions"),
         "opinions": docs.read_doc("opinions"),
         "spec": docs.read_doc("spec"),
         "summary": docs.read_doc("summary"),