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

codex_autorunner/core/pma_queue.py

@@ -83,8 +83,10 @@ class PmaQueue:
         self._lane_queues: dict[str, asyncio.Queue[PmaQueueItem]] = {}
         self._lane_locks: dict[str, asyncio.Lock] = {}
         self._lane_events: dict[str, asyncio.Event] = {}
+        self._lane_known_ids: dict[str, set[str]] = {}
         self._replayed_lanes: set[str] = set()
         self._lock = asyncio.Lock()
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
 
     def _lane_queue_path(self, lane_id: str) -> Path:
         safe_lane_id = lane_id.replace(":", "__COLON__").replace("/", "__SLASH__")
@@ -115,6 +117,21 @@ class PmaQueue:
             self._lane_queues[lane_id] = queue
         return queue
 
+    def _ensure_lane_known_ids(self, lane_id: str) -> set[str]:
+        known = self._lane_known_ids.get(lane_id)
+        if known is None:
+            known = set()
+            self._lane_known_ids[lane_id] = known
+        return known
+
+    def _record_loop(self) -> None:
+        if self._loop is not None:
+            return
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return
+
     async def enqueue(
         self,
         lane_id: str,
@@ -122,6 +139,7 @@ class PmaQueue:
         payload: dict[str, Any],
     ) -> tuple[PmaQueueItem, Optional[str]]:
         async with self._lock:
+            self._record_loop()
             existing = await self._find_by_idempotency_key(lane_id, idempotency_key)
             if existing:
                 if existing.state in (QueueItemState.PENDING, QueueItemState.RUNNING):
@@ -139,10 +157,36 @@ class PmaQueue:
             await self._append_to_file(item)
             queue = self._ensure_lane_queue(lane_id)
             await queue.put(item)
+            self._ensure_lane_known_ids(lane_id).add(item.item_id)
             self._ensure_lane_event(lane_id).set()
             return item, None
 
+    def enqueue_sync(
+        self,
+        lane_id: str,
+        idempotency_key: str,
+        payload: dict[str, Any],
+    ) -> tuple[PmaQueueItem, Optional[str]]:
+        existing = self._find_by_idempotency_key_sync(lane_id, idempotency_key)
+        if existing:
+            if existing.state in (QueueItemState.PENDING, QueueItemState.RUNNING):
+                dedupe_item = PmaQueueItem.create(
+                    lane_id=lane_id,
+                    idempotency_key=idempotency_key,
+                    payload=payload,
+                )
+                dedupe_item.state = QueueItemState.DEDUPED
+                dedupe_item.dedupe_reason = f"duplicate_of_{existing.item_id}"
+                self._append_to_file_sync(dedupe_item)
+                return dedupe_item, f"duplicate of {existing.item_id}"
+
+        item = PmaQueueItem.create(lane_id, idempotency_key, payload)
+        self._append_to_file_sync(item)
+        self._notify_in_memory_enqueue(item)
+        return item, None
+
     async def dequeue(self, lane_id: str) -> Optional[PmaQueueItem]:
+        self._record_loop()
         queue = self._lane_queues.get(lane_id)
         if queue is None or queue.empty():
             return None
@@ -206,11 +250,15 @@ class PmaQueue:
         return cancelled
 
     async def replay_pending(self, lane_id: str) -> int:
+        self._record_loop()
         if lane_id in self._replayed_lanes:
             return 0
         self._replayed_lanes.add(lane_id)
 
         items = await self.list_items(lane_id)
+        known = self._ensure_lane_known_ids(lane_id)
+        for item in items:
+            known.add(item.item_id)
         pending = [item for item in items if item.state == QueueItemState.PENDING]
         if not pending:
             return 0
@@ -222,29 +270,45 @@ class PmaQueue:
         return len(pending)
 
     async def wait_for_lane_item(
-        self, lane_id: str, cancel_event: Optional[asyncio.Event] = None
+        self,
+        lane_id: str,
+        cancel_event: Optional[asyncio.Event] = None,
+        *,
+        poll_interval_seconds: float = 1.0,
     ) -> bool:
+        self._record_loop()
         event = self._ensure_lane_event(lane_id)
         if event.is_set():
             event.clear()
             return True
 
-        wait_tasks = [asyncio.create_task(event.wait())]
-        if cancel_event is not None:
-            wait_tasks.append(asyncio.create_task(cancel_event.wait()))
+        poll_interval = max(0.1, poll_interval_seconds)
+        while True:
+            wait_tasks = [asyncio.create_task(event.wait())]
+            if cancel_event is not None:
+                wait_tasks.append(asyncio.create_task(cancel_event.wait()))
 
-        done, pending = await asyncio.wait(
-            wait_tasks, return_when=asyncio.FIRST_COMPLETED
-        )
-        for task in pending:
-            task.cancel()
+            try:
+                done, pending = await asyncio.wait(
+                    wait_tasks,
+                    timeout=poll_interval,
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+            finally:
+                for task in wait_tasks:
+                    if not task.done():
+                        task.cancel()
 
-        if cancel_event is not None and cancel_event.is_set():
-            return False
+            if cancel_event is not None and cancel_event.is_set():
+                return False
 
-        if event.is_set():
-            event.clear()
-        return True
+            if event.is_set():
+                event.clear()
+                return True
+
+            added = await self._refresh_lane_from_disk(lane_id)
+            if added:
+                return True
 
     async def list_items(self, lane_id: str) -> list[PmaQueueItem]:
         path = self._lane_queue_path(lane_id)
@@ -253,10 +317,11 @@ class PmaQueue:
 
         items: list[PmaQueueItem] = []
         async with self._ensure_lane_lock(lane_id):
-            try:
-                content = path.read_text(encoding="utf-8")
-            except OSError:
-                return []
+            with file_lock(self._lane_queue_lock_path(lane_id)):
+                try:
+                    content = path.read_text(encoding="utf-8")
+                except OSError:
+                    return []
 
             for line in content.strip().splitlines():
                 line = line.strip()
@@ -270,6 +335,29 @@ class PmaQueue:
 
         return items
 
+    async def _refresh_lane_from_disk(self, lane_id: str) -> int:
+        items = await self.list_items(lane_id)
+        if not items:
+            return 0
+
+        known = self._ensure_lane_known_ids(lane_id)
+        new_pending: list[PmaQueueItem] = []
+        for item in items:
+            if item.item_id in known:
+                continue
+            known.add(item.item_id)
+            if item.state == QueueItemState.PENDING:
+                new_pending.append(item)
+
+        if not new_pending:
+            return 0
+
+        queue = self._ensure_lane_queue(lane_id)
+        for item in new_pending:
+            await queue.put(item)
+        self._ensure_lane_event(lane_id).set()
+        return len(new_pending)
+
     async def _find_by_idempotency_key(
         self, lane_id: str, idempotency_key: str
     ) -> Optional[PmaQueueItem]:
@@ -324,6 +412,67 @@ class PmaQueue:
                 if updated:
                     path.write_text("\n".join(lines) + "\n", encoding="utf-8")
 
+    def _append_to_file_sync(self, item: PmaQueueItem) -> None:
+        path = self._lane_queue_path(item.lane_id)
+        with file_lock(self._lane_queue_lock_path(item.lane_id)):
+            path.parent.mkdir(parents=True, exist_ok=True)
+            line = json.dumps(item.to_dict(), separators=(",", ":")) + "\n"
+            with path.open("a", encoding="utf-8") as f:
+                f.write(line)
+
+    def _read_items_sync(self, lane_id: str) -> list[PmaQueueItem]:
+        path = self._lane_queue_path(lane_id)
+        if not path.exists():
+            return []
+
+        items: list[PmaQueueItem] = []
+        with file_lock(self._lane_queue_lock_path(lane_id)):
+            try:
+                content = path.read_text(encoding="utf-8")
+            except OSError:
+                return []
+
+        for line in content.strip().splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                data = json.loads(line)
+                items.append(PmaQueueItem.from_dict(data))
+            except (json.JSONDecodeError, ValueError):
+                continue
+
+        return items
+
+    def _find_by_idempotency_key_sync(
+        self, lane_id: str, idempotency_key: str
+    ) -> Optional[PmaQueueItem]:
+        items = self._read_items_sync(lane_id)
+        for item in items:
+            if item.idempotency_key == idempotency_key and item.state in (
+                QueueItemState.PENDING,
+                QueueItemState.RUNNING,
+            ):
+                return item
+        return None
+
+    def _notify_in_memory_enqueue(self, item: PmaQueueItem) -> None:
+        self._ensure_lane_known_ids(item.lane_id).add(item.item_id)
+        queue = self._lane_queues.get(item.lane_id)
+        event = self._lane_events.get(item.lane_id)
+        loop = self._loop
+        if loop is None or loop.is_closed() or queue is None or event is None:
+            return
+
+        def _enqueue() -> None:
+            queue.put_nowait(item)
+            event.set()
+
+        try:
+            loop.call_soon_threadsafe(_enqueue)
+        except RuntimeError:
+            return
+
     async def get_lane_stats(self, lane_id: str) -> dict[str, Any]:
         items = await self.list_items(lane_id)
         by_state: dict[str, int] = {}

codex_autorunner/core/pma_reactive.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from .locks import file_lock
+from .utils import atomic_write
+
+PMA_REACTIVE_STATE_FILENAME = "reactive_state.json"
+
+logger = logging.getLogger(__name__)
+
+
+def default_pma_reactive_state() -> dict[str, Any]:
+    return {
+        "version": 1,
+        "last_enqueued": {},
+    }
+
+
+class PmaReactiveStore:
+    def __init__(self, hub_root: Path) -> None:
+        self._path = (
+            hub_root / ".codex-autorunner" / "pma" / PMA_REACTIVE_STATE_FILENAME
+        )
+
+    def _lock_path(self) -> Path:
+        return self._path.with_suffix(self._path.suffix + ".lock")
+
+    def load(self) -> dict[str, Any]:
+        with file_lock(self._lock_path()):
+            state = self._load_unlocked()
+            if state is not None:
+                return state
+            state = default_pma_reactive_state()
+            self._save_unlocked(state)
+            return state
+
+    def check_and_update(self, key: str, debounce_seconds: int) -> bool:
+        """
+        Return True if enqueue is allowed; otherwise False if debounced.
+        Updates the last_enqueued timestamp when allowed.
+        """
+        now = time.time()
+        with file_lock(self._lock_path()):
+            state = self._load_unlocked() or default_pma_reactive_state()
+            last_enqueued = state.get("last_enqueued")
+            if not isinstance(last_enqueued, dict):
+                last_enqueued = {}
+                state["last_enqueued"] = last_enqueued
+
+            last = last_enqueued.get(key)
+            if debounce_seconds > 0 and isinstance(last, (int, float)):
+                if now - float(last) < debounce_seconds:
+                    return False
+
+            last_enqueued[key] = now
+            self._save_unlocked(state)
+        return True
+
+    def _load_unlocked(self) -> Optional[dict[str, Any]]:
+        if not self._path.exists():
+            return None
+        try:
+            raw = self._path.read_text(encoding="utf-8")
+        except OSError as exc:
+            logger.warning(
+                "Failed to read PMA reactive state at %s: %s", self._path, exc
+            )
+            return None
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError:
+            return default_pma_reactive_state()
+        if not isinstance(data, dict):
+            return default_pma_reactive_state()
+        return data
+
+    def _save_unlocked(self, state: dict[str, Any]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write(self._path, json.dumps(state, indent=2) + "\n")
+
+
+__all__ = [
+    "PMA_REACTIVE_STATE_FILENAME",
+    "PmaReactiveStore",
+    "default_pma_reactive_state",
+]

codex_autorunner/core/pma_safety.py

@@ -141,6 +141,45 @@ class PmaSafetyChecker:
 
         return SafetyCheckResult(allowed=True)
 
+    def check_reactive_turn(self, *, key: str = "reactive") -> SafetyCheckResult:
+        if self._is_circuit_breaker_active():
+            return SafetyCheckResult(
+                allowed=False,
+                reason="circuit_breaker_active",
+                details={
+                    "cooldown_remaining_seconds": (
+                        int(
+                            self._circuit_breaker_until
+                            - datetime.now(timezone.utc).timestamp()
+                        )
+                        if self._circuit_breaker_until
+                        else 0
+                    )
+                },
+            )
+
+        if self._config.enable_rate_limit:
+            now = datetime.now(timezone.utc).timestamp()
+            self._action_timestamps[key] = [
+                ts
+                for ts in self._action_timestamps[key]
+                if now - ts < self._config.rate_limit_window_seconds
+            ]
+            if len(self._action_timestamps[key]) >= self._config.max_actions_per_window:
+                return SafetyCheckResult(
+                    allowed=False,
+                    reason="rate_limit_exceeded",
+                    details={
+                        "key": key,
+                        "count": len(self._action_timestamps[key]),
+                        "max_allowed": self._config.max_actions_per_window,
+                        "window_seconds": self._config.rate_limit_window_seconds,
+                    },
+                )
+            self._action_timestamps[key].append(now)
+
+        return SafetyCheckResult(allowed=True)
+
     def record_chat_result(
         self,
         agent: str,
@@ -159,6 +198,25 @@ class PmaSafetyChecker:
             key = f"chat:{agent}"
             self._failure_counts[key] = 0
 
+    def record_reactive_result(
+        self,
+        *,
+        status: str,
+        error: Optional[str] = None,
+        key: str = "reactive",
+    ) -> None:
+        if (
+            status in ("error", "failed", "interrupted")
+            and self._config.enable_circuit_breaker
+        ):
+            self._failure_counts[key] += 1
+            if self._failure_counts[key] >= self._config.circuit_breaker_threshold:
+                self._activate_circuit_breaker()
+                if error:
+                    logger.warning("PMA reactive circuit breaker error: %s", error)
+        else:
+            self._failure_counts[key] = 0
+
     def record_action(
         self,
         action_type: PmaActionType,

codex_autorunner/core/pma_sink.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+from .locks import file_lock
+from .time_utils import now_iso
+from .utils import atomic_write
+
+PMA_ACTIVE_SINK_FILENAME = "active_sink.json"
+
+logger = logging.getLogger(__name__)
+
+
+class PmaActiveSinkStore:
+    def __init__(self, hub_root: Path) -> None:
+        self._path = hub_root / ".codex-autorunner" / "pma" / PMA_ACTIVE_SINK_FILENAME
+
+    def _lock_path(self) -> Path:
+        return self._path.with_suffix(self._path.suffix + ".lock")
+
+    def load(self) -> Optional[dict[str, Any]]:
+        with file_lock(self._lock_path()):
+            return self._load_unlocked()
+
+    def set_web(self) -> dict[str, Any]:
+        payload = {
+            "version": 1,
+            "kind": "web",
+            "updated_at": now_iso(),
+            "last_delivery_turn_id": None,
+        }
+        with file_lock(self._lock_path()):
+            self._save_unlocked(payload)
+        return payload
+
+    def set_telegram(
+        self,
+        *,
+        chat_id: int,
+        thread_id: Optional[int],
+        topic_key: Optional[str] = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "version": 1,
+            "kind": "telegram",
+            "chat_id": int(chat_id),
+            "thread_id": int(thread_id) if thread_id is not None else None,
+            "updated_at": now_iso(),
+            "last_delivery_turn_id": None,
+        }
+        if topic_key:
+            payload["topic_key"] = topic_key
+        with file_lock(self._lock_path()):
+            self._save_unlocked(payload)
+        return payload
+
+    def clear(self) -> None:
+        with file_lock(self._lock_path()):
+            try:
+                self._path.unlink()
+            except FileNotFoundError:
+                return
+            except OSError as exc:
+                logger.warning("Failed to clear PMA active sink: %s", exc)
+
+    def mark_delivered(self, turn_id: str) -> bool:
+        if not isinstance(turn_id, str) or not turn_id:
+            return False
+        with file_lock(self._lock_path()):
+            payload = self._load_unlocked()
+            if not isinstance(payload, dict):
+                return False
+            if payload.get("last_delivery_turn_id") == turn_id:
+                return False
+            payload["last_delivery_turn_id"] = turn_id
+            payload["updated_at"] = now_iso()
+            self._save_unlocked(payload)
+        return True
+
+    def _load_unlocked(self) -> Optional[dict[str, Any]]:
+        if not self._path.exists():
+            return None
+        try:
+            raw = self._path.read_text(encoding="utf-8")
+        except OSError as exc:
+            logger.warning("Failed to read PMA active sink: %s", exc)
+            return None
+        try:
+            payload = json.loads(raw)
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(payload, dict):
+            return None
+        return payload
+
+    def _save_unlocked(self, payload: dict[str, Any]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write(self._path, json.dumps(payload, indent=2) + "\n")
+
+
+__all__ = ["PmaActiveSinkStore", "PMA_ACTIVE_SINK_FILENAME"]