145 lines
5.3 KiB
Python
145 lines
5.3 KiB
Python
#!/usr/bin/env python3
|
|
"""Portable file-polling watcher for MACP orchestrator events."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import pathlib
|
|
import sys
|
|
import time
|
|
from collections.abc import Callable
|
|
from typing import Any
|
|
|
|
|
|
def _warn(message: str) -> None:
|
|
print(f"[macp-event-watcher] {message}", file=sys.stderr)
|
|
|
|
|
|
def _load_json(path: pathlib.Path, default: Any) -> Any:
|
|
if not path.exists():
|
|
return default
|
|
try:
|
|
with path.open("r", encoding="utf-8") as handle:
|
|
return json.load(handle)
|
|
except (OSError, json.JSONDecodeError) as exc:
|
|
_warn(f"failed to load cursor {path}: {exc}")
|
|
return default
|
|
|
|
|
|
def _save_json_atomic(path: pathlib.Path, data: Any) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
tmp = path.with_suffix(path.suffix + ".tmp")
|
|
with tmp.open("w", encoding="utf-8") as handle:
|
|
json.dump(data, handle, indent=2)
|
|
handle.write("\n")
|
|
tmp.replace(path)
|
|
|
|
|
|
class EventWatcher:
|
|
"""Poll an events NDJSON file and dispatch matching callbacks."""
|
|
|
|
def __init__(self, events_path: pathlib.Path, cursor_path: pathlib.Path, poll_interval: float = 2.0):
|
|
self.events_path = events_path
|
|
self.cursor_path = cursor_path
|
|
self.poll_interval = max(0.1, float(poll_interval))
|
|
self._callbacks: list[tuple[set[str] | None, Callable[[dict[str, Any]], None]]] = []
|
|
self._cursor_position = self._load_cursor()
|
|
|
|
def on(self, event_types: list[str], callback: Callable[[dict[str, Any]], None]) -> None:
|
|
"""Register a callback for specific event types."""
|
|
|
|
normalized = {str(event_type).strip() for event_type in event_types if str(event_type).strip()}
|
|
self._callbacks.append((normalized or None, callback))
|
|
|
|
def poll_once(self) -> list[dict[str, Any]]:
|
|
"""Read new events since last cursor position. Returns list of new events."""
|
|
|
|
if not self.events_path.exists():
|
|
return []
|
|
|
|
try:
|
|
file_size = self.events_path.stat().st_size
|
|
except OSError as exc:
|
|
_warn(f"failed to stat events file {self.events_path}: {exc}")
|
|
return []
|
|
|
|
if file_size < self._cursor_position:
|
|
_warn(
|
|
f"events file shrank from cursor={self._cursor_position} to size={file_size}; "
|
|
"resetting cursor to start"
|
|
)
|
|
self._cursor_position = 0
|
|
self._persist_cursor()
|
|
|
|
events: list[dict[str, Any]] = []
|
|
new_position = self._cursor_position
|
|
try:
|
|
with self.events_path.open("r", encoding="utf-8") as handle:
|
|
handle.seek(self._cursor_position)
|
|
while True:
|
|
line_start = handle.tell()
|
|
line = handle.readline()
|
|
if not line:
|
|
break
|
|
line_end = handle.tell()
|
|
if not line.endswith("\n"):
|
|
new_position = line_start
|
|
break
|
|
stripped = line.strip()
|
|
if not stripped:
|
|
new_position = line_end
|
|
continue
|
|
try:
|
|
event = json.loads(stripped)
|
|
except json.JSONDecodeError as exc:
|
|
_warn(f"skipping corrupt event at byte {line_start}: {exc}")
|
|
new_position = line_end
|
|
continue
|
|
if not isinstance(event, dict):
|
|
_warn(f"skipping non-object event at byte {line_start}")
|
|
new_position = line_end
|
|
continue
|
|
events.append(event)
|
|
self._dispatch(event)
|
|
new_position = line_end
|
|
except OSError as exc:
|
|
_warn(f"failed to read events file {self.events_path}: {exc}")
|
|
return []
|
|
|
|
if new_position != self._cursor_position:
|
|
self._cursor_position = new_position
|
|
self._persist_cursor()
|
|
return events
|
|
|
|
def run(self, max_iterations: int = 0) -> None:
|
|
"""Polling loop. max_iterations=0 means infinite."""
|
|
|
|
iterations = 0
|
|
while max_iterations <= 0 or iterations < max_iterations:
|
|
self.poll_once()
|
|
iterations += 1
|
|
if max_iterations > 0 and iterations >= max_iterations:
|
|
break
|
|
time.sleep(self.poll_interval)
|
|
|
|
def _dispatch(self, event: dict[str, Any]) -> None:
|
|
event_type = str(event.get("event_type") or "").strip()
|
|
for filters, callback in self._callbacks:
|
|
if filters is not None and event_type not in filters:
|
|
continue
|
|
try:
|
|
callback(event)
|
|
except Exception as exc: # pragma: no cover - defensive boundary
|
|
_warn(f"callback failure for event {event_type or '<unknown>'}: {exc}")
|
|
|
|
def _load_cursor(self) -> int:
|
|
payload = _load_json(self.cursor_path, {"position": 0})
|
|
try:
|
|
position = int(payload.get("position", 0))
|
|
except (AttributeError, TypeError, ValueError):
|
|
position = 0
|
|
return max(0, position)
|
|
|
|
def _persist_cursor(self) -> None:
|
|
_save_json_atomic(self.cursor_path, {"position": self._cursor_position})
|