codex-autorunner 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

codex_autorunner/core/lifecycle_events.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from .locks import file_lock
+from .utils import atomic_write
+
+logger = logging.getLogger(__name__)
+
+LIFECYCLE_EVENTS_FILENAME = "lifecycle_events.json"
+LIFECYCLE_EVENTS_LOCK_SUFFIX = ".lock"
+
+
+class LifecycleEventType(str, Enum):
+    FLOW_PAUSED = "flow_paused"
+    FLOW_COMPLETED = "flow_completed"
+    FLOW_FAILED = "flow_failed"
+    FLOW_STOPPED = "flow_stopped"
+    DISPATCH_CREATED = "dispatch_created"
+
+
+@dataclass
+class LifecycleEvent:
+    event_type: LifecycleEventType
+    repo_id: str
+    run_id: str
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    processed: bool = False
+    event_id: str = ""
+
+    def __post_init__(self):
+        if not self.event_id:
+            import uuid
+
+            object.__setattr__(self, "event_id", str(uuid.uuid4()))
+
+
+def default_lifecycle_events_path(hub_root: Path) -> Path:
+    return hub_root / ".codex-autorunner" / LIFECYCLE_EVENTS_FILENAME
+
+
+class LifecycleEventStore:
+    def __init__(self, hub_root: Path) -> None:
+        self._path = default_lifecycle_events_path(hub_root)
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def _lock_path(self) -> Path:
+        return self._path.with_suffix(LIFECYCLE_EVENTS_LOCK_SUFFIX)
+
+    def load(self, *, ensure_exists: bool = True) -> list[LifecycleEvent]:
+        with file_lock(self._lock_path()):
+            if not self._path.exists():
+                return []
+            try:
+                raw = self._path.read_text(encoding="utf-8")
+            except OSError as exc:
+                logger.warning(
+                    "Failed to read lifecycle events at %s: %s", self._path, exc
+                )
+                return []
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError as exc:
+                logger.warning(
+                    "Failed to parse lifecycle events at %s: %s", self._path, exc
+                )
+                return []
+            if not isinstance(data, list):
+                logger.warning("Lifecycle events data is not a list: %s", self._path)
+                return []
+            events: list[LifecycleEvent] = []
+            for entry in data:
+                try:
+                    if not isinstance(entry, dict):
+                        continue
+                    event_type_str = entry.get("event_type")
+                    if not isinstance(event_type_str, str):
+                        continue
+                    try:
+                        event_type = LifecycleEventType(event_type_str)
+                    except ValueError:
+                        continue
+                    event_id_raw = entry.get("event_id")
+                    event_id = (
+                        str(event_id_raw) if isinstance(event_id_raw, str) else ""
+                    )
+                    if not event_id:
+                        import uuid
+
+                        event_id = str(uuid.uuid4())
+                    event = LifecycleEvent(
+                        event_type=event_type,
+                        repo_id=str(entry.get("repo_id", "")),
+                        run_id=str(entry.get("run_id", "")),
+                        data=dict(entry.get("data", {})),
+                        timestamp=str(entry.get("timestamp", "")),
+                        processed=bool(entry.get("processed", False)),
+                        event_id=event_id,
+                    )
+                    events.append(event)
+                except Exception as exc:
+                    logger.debug("Failed to parse lifecycle event entry: %s", exc)
+                    continue
+            return events
+
+    def save(self, events: list[LifecycleEvent]) -> None:
+        with file_lock(self._lock_path()):
+            self._save_unlocked(events)
+
+    def _save_unlocked(self, events: list[LifecycleEvent]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        data = [
+            {
+                "event_id": event.event_id,
+                "event_type": event.event_type.value,
+                "repo_id": event.repo_id,
+                "run_id": event.run_id,
+                "data": event.data,
+                "timestamp": event.timestamp,
+                "processed": event.processed,
+            }
+            for event in events
+        ]
+        atomic_write(self._path, json.dumps(data, indent=2) + "\n")
+
+    def append(self, event: LifecycleEvent) -> None:
+        events = self.load(ensure_exists=False)
+        events.append(event)
+        self.save(events)
+
+    def mark_processed(self, event_id: str) -> Optional[LifecycleEvent]:
+        if not event_id:
+            return None
+        events = self.load(ensure_exists=False)
+        updated = None
+        for event in events:
+            if event.event_id == event_id:
+                event.processed = True
+                updated = event
+                break
+        if updated:
+            self.save(events)
+        return updated
+
+    def get_unprocessed(self, *, limit: int = 100) -> list[LifecycleEvent]:
+        events = self.load(ensure_exists=False)
+        unprocessed = [e for e in events if not e.processed]
+        return unprocessed[:limit]
+
+    def prune_processed(self, *, keep_last: int = 100) -> None:
+        events = self.load(ensure_exists=False)
+        unprocessed = [e for e in events if not e.processed]
+        processed = [e for e in events if e.processed]
+        if len(processed) > keep_last:
+            processed = processed[-keep_last:]
+        self.save(unprocessed + processed)
+
+
+class LifecycleEventEmitter:
+    def __init__(self, hub_root: Path) -> None:
+        self._store = LifecycleEventStore(hub_root)
+        self._listeners: list[Callable[[LifecycleEvent], None]] = []
+
+    def emit(self, event: LifecycleEvent) -> str:
+        self._store.append(event)
+        for listener in self._listeners:
+            try:
+                listener(event)
+            except Exception as exc:
+                logger.exception("Error in lifecycle event listener: %s", exc)
+        return event.event_id
+
+    def emit_flow_paused(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_PAUSED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_flow_completed(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_COMPLETED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_flow_failed(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_FAILED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_flow_stopped(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.FLOW_STOPPED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def emit_dispatch_created(
+        self, repo_id: str, run_id: str, *, data: Optional[dict[str, Any]] = None
+    ) -> str:
+        event = LifecycleEvent(
+            event_type=LifecycleEventType.DISPATCH_CREATED,
+            repo_id=repo_id,
+            run_id=run_id,
+            data=data or {},
+        )
+        return self.emit(event)
+
+    def add_listener(self, listener: Callable[[LifecycleEvent], None]) -> None:
+        self._listeners.append(listener)
+
+    def remove_listener(self, listener: Callable[[LifecycleEvent], None]) -> None:
+        self._listeners = [lst for lst in self._listeners if lst != listener]
+
+
+__all__ = [
+    "LifecycleEventType",
+    "LifecycleEvent",
+    "LifecycleEventStore",
+    "LifecycleEventEmitter",
+    "default_lifecycle_events_path",
+]

codex_autorunner/core/path_utils.py

@@ -49,6 +49,7 @@ def resolve_config_path(
     3. Otherwise, resolve relative to repo_root
     4. Reject '..' segments unless allow_dotdot=True
     5. Reject paths escaping repo_root (except home expansion)
+       - allow_dotdot allows '..' segments inside the repo, not escaping the repo
 
     Args:
         value: Path string or Path object
@@ -112,7 +113,7 @@ def resolve_config_path(
 
     resolved = (repo_root / path).resolve()
 
-    if not allow_home and not allow_dotdot and not resolved.is_relative_to(repo_root):
+    if not resolved.is_relative_to(repo_root):
         raise ConfigPathError(
             "Path resolves outside repo root",
             path=value_str,

codex_autorunner/core/pma_audit.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Optional
+
+from .locks import file_lock
+
+logger = logging.getLogger(__name__)
+
+PMA_AUDIT_LOG_FILENAME = "audit_log.jsonl"
+PMA_AUDIT_LOG_LOCK_SUFFIX = ".lock"
+
+
+class PmaActionType(str, Enum):
+    CHAT_STARTED = "chat_started"
+    CHAT_COMPLETED = "chat_completed"
+    CHAT_FAILED = "chat_failed"
+    CHAT_INTERRUPTED = "chat_interrupted"
+    FILE_UPLOADED = "file_uploaded"
+    FILE_DOWNLOADED = "file_downloaded"
+    FILE_DELETED = "file_deleted"
+    FILE_BULK_DELETED = "file_bulk_deleted"
+    DOC_UPDATED = "doc_updated"
+    DISPATCH_PROCESSED = "dispatch_processed"
+    AGENT_ACTION = "agent_action"
+    SESSION_NEW = "session_new"
+    SESSION_RESET = "session_reset"
+    SESSION_STOP = "session_stop"
+    SESSION_COMPACT = "session_compact"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class PmaAuditEntry:
+    action_type: PmaActionType
+    timestamp: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    entry_id: str = ""
+    agent: Optional[str] = None
+    thread_id: Optional[str] = None
+    turn_id: Optional[str] = None
+    client_turn_id: Optional[str] = None
+    details: dict[str, Any] = field(default_factory=dict)
+    status: str = "ok"
+    error: Optional[str] = None
+    fingerprint: str = ""
+
+    def __post_init__(self):
+        if not self.entry_id:
+            import uuid
+
+            object.__setattr__(self, "entry_id", str(uuid.uuid4()))
+        if not self.fingerprint:
+            object.__setattr__(self, "fingerprint", self._compute_fingerprint())
+
+    def _compute_fingerprint(self) -> str:
+        base = {
+            "action_type": self.action_type.value,
+            "agent": self.agent,
+            "details": self.details,
+        }
+        raw = json.dumps(base, sort_keys=True, default=str)
+        return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+def default_pma_audit_log_path(hub_root: Path) -> Path:
+    return hub_root / ".codex-autorunner" / "pma" / PMA_AUDIT_LOG_FILENAME
+
+
+class PmaAuditLog:
+    def __init__(self, hub_root: Path) -> None:
+        self._path = default_pma_audit_log_path(hub_root)
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def _lock_path(self) -> Path:
+        return self._path.with_suffix(PMA_AUDIT_LOG_LOCK_SUFFIX)
+
+    def append(self, entry: PmaAuditEntry) -> str:
+        with file_lock(self._lock_path()):
+            self._append_unlocked(entry)
+        return entry.entry_id
+
+    def _append_unlocked(self, entry: PmaAuditEntry) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        line = json.dumps(
+            {
+                "entry_id": entry.entry_id,
+                "action_type": entry.action_type.value,
+                "timestamp": entry.timestamp,
+                "agent": entry.agent,
+                "thread_id": entry.thread_id,
+                "turn_id": entry.turn_id,
+                "client_turn_id": entry.client_turn_id,
+                "details": entry.details,
+                "status": entry.status,
+                "error": entry.error,
+                "fingerprint": entry.fingerprint,
+            }
+        )
+        with open(self._path, "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+
+    def list_recent(
+        self, *, limit: int = 100, action_type: Optional[PmaActionType] = None
+    ) -> list[PmaAuditEntry]:
+        with file_lock(self._lock_path()):
+            return self._list_recent_unlocked(limit=limit, action_type=action_type)
+
+    def _list_recent_unlocked(
+        self, *, limit: int = 100, action_type: Optional[PmaActionType] = None
+    ) -> list[PmaAuditEntry]:
+        if not self._path.exists():
+            return []
+        entries: list[PmaAuditEntry] = []
+        try:
+            with open(self._path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        data = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if not isinstance(data, dict):
+                        continue
+                    try:
+                        action_type_str = data.get("action_type")
+                        event_type = (
+                            PmaActionType(action_type_str)
+                            if action_type_str
+                            else PmaActionType.UNKNOWN
+                        )
+                    except ValueError:
+                        event_type = PmaActionType.UNKNOWN
+                    if action_type and event_type != action_type:
+                        continue
+                    entry = PmaAuditEntry(
+                        action_type=event_type,
+                        timestamp=data.get("timestamp", ""),
+                        entry_id=data.get("entry_id", ""),
+                        agent=data.get("agent"),
+                        thread_id=data.get("thread_id"),
+                        turn_id=data.get("turn_id"),
+                        client_turn_id=data.get("client_turn_id"),
+                        details=dict(data.get("details", {}) or {}),
+                        status=data.get("status", "ok"),
+                        error=data.get("error"),
+                        fingerprint=data.get("fingerprint", ""),
+                    )
+                    entries.append(entry)
+        except OSError as exc:
+            logger.warning("Failed to read PMA audit log at %s: %s", self._path, exc)
+        return entries[-limit:]
+
+    def prune_old(self, *, keep_last: int = 1000) -> int:
+        with file_lock(self._lock_path()):
+            return self._prune_old_unlocked(keep_last=keep_last)
+
+    def _prune_old_unlocked(self, *, keep_last: int = 1000) -> int:
+        if not self._path.exists():
+            return 0
+        entries = self._list_recent_unlocked(limit=keep_last * 2)
+        if len(entries) <= keep_last:
+            return 0
+        to_keep = entries[-keep_last:]
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self._path, "w", encoding="utf-8") as f:
+            for entry in to_keep:
+                line = json.dumps(
+                    {
+                        "entry_id": entry.entry_id,
+                        "action_type": entry.action_type.value,
+                        "timestamp": entry.timestamp,
+                        "agent": entry.agent,
+                        "thread_id": entry.thread_id,
+                        "turn_id": entry.turn_id,
+                        "client_turn_id": entry.client_turn_id,
+                        "details": entry.details,
+                        "status": entry.status,
+                        "error": entry.error,
+                        "fingerprint": entry.fingerprint,
+                    }
+                )
+                f.write(line + "\n")
+        return len(entries) - keep_last
+
+    def count_fingerprint(
+        self, fingerprint: str, *, within_seconds: Optional[int] = None
+    ) -> int:
+        if not within_seconds:
+            return sum(
+                1
+                for e in self._list_recent_unlocked(limit=10000)
+                if e.fingerprint == fingerprint
+            )
+        cutoff = datetime.now(timezone.utc).timestamp() - within_seconds
+        count = 0
+        for entry in self._list_recent_unlocked(limit=10000):
+            try:
+                ts = datetime.fromisoformat(entry.timestamp.replace("Z", "+00:00"))
+                if ts.timestamp() >= cutoff and entry.fingerprint == fingerprint:
+                    count += 1
+            except Exception:
+                continue
+        return count
+
+
+__all__ = [
+    "PmaActionType",
+    "PmaAuditEntry",
+    "PmaAuditLog",
+    "default_pma_audit_log_path",
+]