ctrlrelay 0.1.5__py3-none-any.whl

ctrlrelay/dashboard/client.py

@@ -0,0 +1,159 @@
+"""Dashboard client for event push and heartbeat."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import httpx
+from pydantic import BaseModel
+
+from ctrlrelay import __version__
+
+
+class HeartbeatPayload(BaseModel):
+    """Payload for heartbeat endpoint."""
+
+    node_id: str
+    timestamp: str = ""
+    version: str = __version__
+    uptime_seconds: int = 0
+    platform: str = ""
+    active_sessions: list[dict[str, Any]] = []
+    last_github_poll: str | None = None
+    last_github_poll_status: str = "ok"
+    repos_configured: int = 0
+    repos_active: int = 0
+
+    def model_post_init(self, __context: Any) -> None:
+        if not self.timestamp:
+            object.__setattr__(self, "timestamp", datetime.now(timezone.utc).isoformat())
+
+
+class EventPayload(BaseModel):
+    """Payload for event endpoint."""
+
+    level: str  # info, warning, error
+    pipeline: str  # secops, dev
+    repo: str
+    message: str
+    session_id: str | None = None
+    timestamp: str = ""
+    details: dict[str, Any] = {}
+
+    def model_post_init(self, __context: Any) -> None:
+        if not self.timestamp:
+            object.__setattr__(
+                self, "timestamp", datetime.now(timezone.utc).isoformat()
+            )
+
+
+@dataclass
+class DashboardClient:
+    """Client for dashboard API with offline queue."""
+
+    url: str
+    auth_token: str
+    node_id: str
+    queue_dir: Path | None = None
+    timeout: int = 30
+    max_retries: int = 3
+    _queue: list[dict[str, Any]] = field(default_factory=list, repr=False)
+
+    def __post_init__(self) -> None:
+        if self.queue_dir:
+            self.queue_dir = Path(self.queue_dir)
+            self.queue_dir.mkdir(parents=True, exist_ok=True)
+            self._load_queue()
+
+    def _load_queue(self) -> None:
+        """Load queued events from disk."""
+        if not self.queue_dir:
+            return
+        queue_file = self.queue_dir / "event_queue.json"
+        if queue_file.exists():
+            try:
+                self._queue = json.loads(queue_file.read_text())
+            except json.JSONDecodeError:
+                self._queue = []
+
+    def _save_queue(self) -> None:
+        """Save queued events to disk."""
+        if not self.queue_dir:
+            return
+        queue_file = self.queue_dir / "event_queue.json"
+        queue_file.write_text(json.dumps(self._queue))
+
+    def _queue_event(self, event: EventPayload) -> None:
+        """Add event to offline queue."""
+        self._queue.append(event.model_dump())
+        self._save_queue()
+
+    async def push_event(self, event: EventPayload) -> bool:
+        """Push event to dashboard, queue on failure."""
+        payload = event.model_dump()
+        payload["node_id"] = self.node_id
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(
+                    f"{self.url}/event",
+                    json=payload,
+                    headers={"Authorization": f"Bearer {self.auth_token}"},
+                )
+                response.raise_for_status()
+                return True
+        except (httpx.HTTPError, httpx.TimeoutException):
+            self._queue_event(event)
+            return False
+
+    async def heartbeat(self, payload: HeartbeatPayload) -> bool:
+        """Send heartbeat to dashboard."""
+        data = payload.model_dump()
+        data["node_id"] = self.node_id
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(
+                    f"{self.url}/heartbeat",
+                    json=data,
+                    headers={"Authorization": f"Bearer {self.auth_token}"},
+                )
+                response.raise_for_status()
+                return True
+        except (httpx.HTTPError, httpx.TimeoutException):
+            return False
+
+    async def drain_queue(self) -> int:
+        """Attempt to send queued events. Returns count of successfully sent."""
+        if not self._queue:
+            return 0
+
+        sent = 0
+        remaining = []
+
+        for event_data in self._queue:
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    event_data["node_id"] = self.node_id
+                    response = await client.post(
+                        f"{self.url}/event",
+                        json=event_data,
+                        headers={"Authorization": f"Bearer {self.auth_token}"},
+                    )
+                    response.raise_for_status()
+                    sent += 1
+            except (httpx.HTTPError, httpx.TimeoutException):
+                remaining.append(event_data)
+
+        self._queue = remaining
+        self._save_queue()
+        return sent
+
+    @property
+    def queue_size(self) -> int:
+        """Number of events in offline queue."""
+        return len(self._queue)

ctrlrelay/pipelines/__init__.py

@@ -0,0 +1,15 @@
+"""Pipeline implementations for ctrlrelay."""
+
+from ctrlrelay.pipelines.base import Pipeline, PipelineContext, PipelineResult
+from ctrlrelay.pipelines.dev import DevPipeline, run_dev_issue
+from ctrlrelay.pipelines.secops import SecopsPipeline, run_secops_all
+
+__all__ = [
+    "Pipeline",
+    "PipelineContext",
+    "PipelineResult",
+    "SecopsPipeline",
+    "run_secops_all",
+    "DevPipeline",
+    "run_dev_issue",
+]

ctrlrelay/pipelines/base.py

@@ -0,0 +1,50 @@
+"""Base protocol and types for pipelines."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+
+@dataclass
+class PipelineContext:
+    """Context for a pipeline execution."""
+
+    session_id: str
+    repo: str
+    worktree_path: Path
+    context_path: Path
+    state_file: Path
+    issue_number: int | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class PipelineResult:
+    """Result of a pipeline execution."""
+
+    success: bool
+    session_id: str
+    summary: str
+    blocked: bool = False
+    question: str | None = None
+    error: str | None = None
+    outputs: dict[str, Any] = field(default_factory=dict)
+
+
+@runtime_checkable
+class Pipeline(Protocol):
+    """Protocol for pipeline implementations."""
+
+    name: str
+
+    async def run(self, ctx: PipelineContext) -> PipelineResult:
+        """Execute the pipeline."""
+        ...
+
+    async def resume(
+        self, ctx: PipelineContext, answer: str
+    ) -> PipelineResult:
+        """Resume a blocked pipeline with user answer."""
+        ...