ctrlrelay 0.1.5__py3-none-any.whl

ctrlrelay/transports/base.py

@@ -0,0 +1,47 @@
+"""Transport protocol definition."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+class TransportError(Exception):
+    """Raised when transport operations fail."""
+
+
+@runtime_checkable
+class Transport(Protocol):
+    """Protocol for orchestrator-to-human communication.
+
+    Implementations accept optional correlation kwargs (``session_id``,
+    ``repo``, ``issue_number``) used solely for structured logging — they are
+    never part of the wire payload.
+    """
+
+    async def send(
+        self,
+        message: str,
+        *,
+        session_id: str | None = None,
+        repo: str | None = None,
+        issue_number: int | None = None,
+    ) -> None:
+        """Send a one-way message (no response expected)."""
+        ...
+
+    async def ask(
+        self,
+        question: str,
+        options: list[str] | None = None,
+        timeout: int = 300,
+        *,
+        session_id: str | None = None,
+        repo: str | None = None,
+        issue_number: int | None = None,
+    ) -> str:
+        """Ask a question and wait for response."""
+        ...
+
+    async def close(self) -> None:
+        """Close the transport connection."""
+        ...

ctrlrelay/transports/file_mock.py

@@ -0,0 +1,94 @@
+"""File-based mock transport for testing."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+from ctrlrelay.core.obs import get_logger, hash_text, log_event
+from ctrlrelay.transports.base import TransportError
+
+_logger = get_logger("transport.file_mock")
+
+
+class FileMockTransport:
+    """Transport that reads/writes to files for testing."""
+
+    def __init__(self, inbox: Path, outbox: Path) -> None:
+        self.inbox = inbox
+        self.outbox = outbox
+
+    async def send(
+        self,
+        message: str,
+        *,
+        session_id: str | None = None,
+        repo: str | None = None,
+        issue_number: int | None = None,
+    ) -> None:
+        """Write message to outbox file."""
+        timestamp = datetime.now(timezone.utc).isoformat()
+        with self.outbox.open("a") as f:
+            f.write(f"[{timestamp}] {message}\n")
+
+    async def ask(
+        self,
+        question: str,
+        options: list[str] | None = None,
+        timeout: int = 300,
+        *,
+        session_id: str | None = None,
+        repo: str | None = None,
+        issue_number: int | None = None,
+    ) -> str:
+        """Write question to outbox and poll inbox for answer."""
+        timestamp = datetime.now(timezone.utc).isoformat()
+        opts = f" [{'/'.join(options)}]" if options else ""
+        with self.outbox.open("a") as f:
+            f.write(f"[{timestamp}] QUESTION: {question}{opts}\n")
+
+        log_event(
+            _logger,
+            "dev.question.posted",
+            session_id=session_id,
+            repo=repo,
+            issue_number=issue_number,
+            transport="file_mock",
+            destination=str(self.outbox),
+            question=question,
+            question_length=len(question),
+            question_hash=hash_text(question),
+            options=options,
+        )
+
+        sent_at = time.monotonic()
+        start = asyncio.get_event_loop().time()
+        while True:
+            content = self.inbox.read_text().strip()
+            if content:
+                self.inbox.write_text("")
+                answer = content.split("\n")[0].strip()
+                log_event(
+                    _logger,
+                    "dev.answer.received",
+                    session_id=session_id,
+                    repo=repo,
+                    issue_number=issue_number,
+                    transport="file_mock",
+                    answer=answer,
+                    answer_length=len(answer),
+                    answer_hash=hash_text(answer),
+                    elapsed_ms=int((time.monotonic() - sent_at) * 1000),
+                )
+                return answer
+
+            if asyncio.get_event_loop().time() - start > timeout:
+                raise TransportError(f"ask() timeout after {timeout}s")
+
+            await asyncio.sleep(0.5)
+
+    async def close(self) -> None:
+        """No-op for file transport."""
+        pass

ctrlrelay/transports/socket_client.py

@@ -0,0 +1,180 @@
+"""Unix socket transport client for bridge communication."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from pathlib import Path
+
+from ctrlrelay.bridge.protocol import (
+    BridgeMessage,
+    BridgeOp,
+    ProtocolError,
+    parse_message,
+    serialize_message,
+)
+from ctrlrelay.core.obs import get_logger, hash_text, log_event
+from ctrlrelay.transports.base import TransportError
+
+_logger = get_logger("transport.socket")
+
+
+class SocketTransport:
+    """Transport that connects to bridge via Unix socket."""
+
+    def __init__(self, socket_path: Path) -> None:
+        self.socket_path = socket_path
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+        self._pending: dict[str, asyncio.Future[BridgeMessage]] = {}
+        self._receive_task: asyncio.Task | None = None
+
+    @property
+    def connected(self) -> bool:
+        return self._writer is not None and not self._writer.is_closing()
+
+    async def connect(self) -> None:
+        """Connect to bridge socket."""
+        try:
+            self._reader, self._writer = await asyncio.open_unix_connection(
+                str(self.socket_path)
+            )
+            self._receive_task = asyncio.create_task(self._receive_loop())
+        except (OSError, ConnectionRefusedError) as e:
+            raise TransportError(f"Failed to connect to bridge: {e}") from e
+
+    async def _receive_loop(self) -> None:
+        """Background task to receive messages from bridge."""
+        assert self._reader is not None
+        try:
+            while True:
+                line = await self._reader.readline()
+                if not line:
+                    break
+                try:
+                    msg = parse_message(line.decode())
+                    if msg.request_id and msg.request_id in self._pending:
+                        self._pending[msg.request_id].set_result(msg)
+                except ProtocolError:
+                    pass
+        except asyncio.CancelledError:
+            pass
+
+    async def _send_message(self, msg: BridgeMessage) -> None:
+        """Send message to bridge."""
+        if not self.connected:
+            raise TransportError("Transport not connected")
+        assert self._writer is not None
+        data = serialize_message(msg).encode()
+        self._writer.write(data)
+        await self._writer.drain()
+
+    async def _send_and_wait(self, msg: BridgeMessage, timeout: int) -> BridgeMessage:
+        """Send message and wait for response."""
+        assert msg.request_id is not None
+        future: asyncio.Future[BridgeMessage] = asyncio.get_event_loop().create_future()
+        self._pending[msg.request_id] = future
+
+        try:
+            await self._send_message(msg)
+            return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError as e:
+            raise TransportError("Timeout waiting for response") from e
+        finally:
+            self._pending.pop(msg.request_id, None)
+
+    async def send(
+        self,
+        message: str,
+        *,
+        session_id: str | None = None,
+        repo: str | None = None,
+        issue_number: int | None = None,
+    ) -> None:
+        """Send a one-way message."""
+        request_id = f"r-{uuid.uuid4().hex[:8]}"
+        msg = BridgeMessage(
+            op=BridgeOp.SEND,
+            request_id=request_id,
+            text=message,
+            session_id=session_id,
+            repo=repo,
+            issue_number=issue_number,
+        )
+        await self._send_message(msg)
+
+    async def ask(
+        self,
+        question: str,
+        options: list[str] | None = None,
+        timeout: int = 300,
+        *,
+        session_id: str | None = None,
+        repo: str | None = None,
+        issue_number: int | None = None,
+    ) -> str:
+        """Ask a question and wait for response."""
+        request_id = f"r-{uuid.uuid4().hex[:8]}"
+        msg = BridgeMessage(
+            op=BridgeOp.ASK,
+            request_id=request_id,
+            question=question,
+            options=options,
+            timeout=timeout,
+            session_id=session_id,
+            repo=repo,
+            issue_number=issue_number,
+        )
+
+        log_event(
+            _logger,
+            "dev.question.posted",
+            session_id=session_id,
+            repo=repo,
+            issue_number=issue_number,
+            transport="socket",
+            destination=str(self.socket_path),
+            request_id=request_id,
+            question=question,
+            question_length=len(question),
+            question_hash=hash_text(question),
+            options=options,
+        )
+
+        sent_at = time.monotonic()
+        response = await self._send_and_wait(msg, timeout)
+
+        if response.op == BridgeOp.ERROR:
+            raise TransportError(f"Bridge error: {response.message}")
+        if response.op == BridgeOp.ANSWER and response.answer:
+            log_event(
+                _logger,
+                "dev.answer.received",
+                session_id=session_id,
+                repo=repo,
+                issue_number=issue_number,
+                transport="socket",
+                request_id=request_id,
+                answer=response.answer,
+                answer_length=len(response.answer),
+                answer_hash=hash_text(response.answer),
+                elapsed_ms=int((time.monotonic() - sent_at) * 1000),
+            )
+            return response.answer
+
+        raise TransportError(f"Unexpected response: {response.op}")
+
+    async def close(self) -> None:
+        """Close the connection."""
+        if self._receive_task:
+            self._receive_task.cancel()
+            try:
+                await self._receive_task
+            except asyncio.CancelledError:
+                pass
+        if self._writer:
+            self._writer.close()
+            await self._writer.wait_closed()
+        self._reader = None
+        self._writer = None

ctrlrelay-0.1.5.dist-info/METADATA

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: ctrlrelay
+Version: 0.1.5
+Summary: Local-first orchestrator for headless coding agents across multiple GitHub repos
+Project-URL: Homepage, https://github.com/AInvirion/ctrlrelay
+Project-URL: Documentation, https://ainvirion.github.io/ctrlrelay/
+Project-URL: Repository, https://github.com/AInvirion/ctrlrelay
+Project-URL: Issues, https://github.com/AInvirion/ctrlrelay/issues
+Project-URL: Changelog, https://github.com/AInvirion/ctrlrelay/blob/main/CHANGELOG.md
+Author-email: Oscar Valenzuela <oscar.valenzuela.b@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: automation,claude,github,orchestrator
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.12
+Requires-Dist: apscheduler>=3.10.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-telegram-bot>=21.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ctrlrelay
+
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Tests and lint](https://github.com/AInvirion/ctrlrelay/actions/workflows/test.yml/badge.svg)](https://github.com/AInvirion/ctrlrelay/actions/workflows/test.yml)
+[![Build](https://github.com/AInvirion/ctrlrelay/actions/workflows/build.yml/badge.svg)](https://github.com/AInvirion/ctrlrelay/actions/workflows/build.yml)
+[![Python](https://img.shields.io/badge/python-3.12%20%7C%203.13%20%7C%203.14-blue)](https://pypi.org/project/ctrlrelay/)
+[![GitHub Issues](https://img.shields.io/github/issues/AInvirion/ctrlrelay.svg)](https://github.com/AInvirion/ctrlrelay/issues)
+[![GitHub Pull Requests](https://img.shields.io/github/issues-pr/AInvirion/ctrlrelay.svg)](https://github.com/AInvirion/ctrlrelay/pulls)
+
+> Local-first orchestrator for headless coding agents across your GitHub
+> repos. Watches for assigned issues, runs a dev pipeline in an isolated
+> git worktree, opens a PR, and asks you on Telegram when it gets stuck.
+
+## Table of Contents
+
+- [About](#about)
+- [Features](#features)
+- [How it works](#how-it-works)
+- [Getting started](#getting-started)
+  - [Prerequisites](#prerequisites)
+  - [Installation](#installation)
+  - [Quick start](#quick-start)
+- [Documentation](#documentation)
+- [Roadmap](#roadmap)
+- [Contributing](#contributing)
+- [Security](#security)
+- [License](#license)
+
+## About
+
+Headless coding agents are great interactively. Running them across half
+a dozen repos without staring at a terminal is a different problem: who
+schedules the runs, who watches for new work, who hands you the "I'm
+blocked, what do you want?" question, who tracks the PR until it merges.
+
+`ctrlrelay` is a small daemon that does all of that on your laptop. It
+is local-first on purpose: no server, no queue, no multi-tenant anything.
+Your agent credentials, your GitHub credentials, your repos, your
+machine.
+
+Today `ctrlrelay` ships with a Claude Code (`claude -p`) backend. The
+orchestrator layer — worktrees, state DB, scheduler, Telegram bridge —
+is agent-agnostic, and plug-in backends for other headless coding agents
+are on the roadmap (see [Roadmap](#roadmap)).
+
+## Features
+
+- **Issue poller.** Detects issues assigned to you across every
+  configured repo, spawns a dev session in a dedicated git worktree,
+  and opens a PR.
+- **Telegram bridge.** When a session hits a blocking question, the
+  bridge relays it to you as a DM and resumes the session once you
+  reply.
+- **PR watcher.** Tracks the opened PR to merge and closes the loop
+  with a Telegram notification.
+- **In-process scheduler** (APScheduler). Runs periodic jobs inside
+  the poller daemon. Ships with a `secops` job that reviews Dependabot
+  alerts and PRs daily at 6am; cron expressions follow standard Vixie
+  5-field semantics (Sun=0, DOM-OR-DOW).
+- **Checkpoint protocol.** The agent writes a structured state file
+  at the end of every session so the orchestrator knows whether it
+  succeeded, failed, or is blocked on input. Agent backends implement
+  this protocol to integrate.
+- **Cross-platform supervision.** launchd (macOS) and systemd (Linux)
+  examples in `docs/operations.md`. One codebase, identical behavior.
+
+## How it works
+
+```
+             ┌───────────────┐
+             │  GitHub API   │
+             └───────┬───────┘
+                     │ (poll: issues assigned to me)
+             ┌───────▼───────┐         ┌──────────────┐
+             │ poller daemon │◄────────┤   APScheduler│
+             │  (launchd /   │         │ (secops cron)│
+             │   systemd)    │         └──────────────┘
+             └───┬───────┬───┘
+      new issue  │       │  blocked session
+                 │       │
+      ┌──────────▼──┐  ┌─▼───────────────────┐
+      │ dev pipeline│  │ Telegram bridge     │
+      │ in worktree │  │ (socket ↔ bot API)  │
+      │ agent CLI   │  └──────────┬──────────┘
+      └──────┬──────┘             │
+             │ PR opened          │ DM you
+             ▼                    ▼
+      ┌────────────┐         ┌─────────┐
+      │ PR watcher │         │   You   │
+      └────────────┘         └─────────┘
+```
+
+Under the hood it's Python + `asyncio` + `sqlite` for state. The agent
+is invoked as a subprocess (today: `claude -p`), and GitHub is accessed
+via the `gh` CLI. No web server, no queue, no database dependency — just
+a launchd/systemd-supervised daemon.
+
+## Getting started
+
+### Prerequisites
+
+- **Python 3.12+**
+- **git 2.20+**
+- The **[`gh` CLI][gh-cli]**, authenticated (`gh auth login`) — used for
+  all GitHub API calls.
+- A **headless coding agent backend.** Today that means the
+  **[`claude` CLI][claude-cli]**, authenticated (`claude auth login`).
+  Future backends will document their own setup.
+- *(Optional, for the `secops` pipeline)* the **[`codex` CLI][codex-cli]**,
+  authenticated. The secops pipeline invokes `codex review` as an
+  independent reviewer for the agent's output; you can disable it by
+  setting `code_review.method: "none"` in your config if you prefer to
+  skip the review step.
+- *(Optional)* a Telegram bot token if you want the bridge — see
+  [Telegram bridge docs][docs-bridge].
+
+### Installation
+
+**From PyPI** (once published):
+
+```bash
+pip install ctrlrelay
+# or: uv pip install ctrlrelay
+```
+
+**From source** (current path while in alpha):
+
+```bash
+git clone https://github.com/AInvirion/ctrlrelay.git
+cd ctrlrelay
+uv pip install -e .   # or: pip install -e .
+```
+
+### Quick start
+
+```bash
+# Copy and edit the example config:
+cp config/orchestrator.yaml.example config/orchestrator.yaml
+
+# Validate it:
+ctrlrelay config validate
+
+# Run the dev pipeline against an issue you're assigned:
+ctrlrelay run dev --issue 42 --repo your-org/your-repo
+
+# Or start the poller to auto-process newly assigned issues + run the
+# scheduled secops sweep daily at 6am:
+ctrlrelay poller start      # daemonizes; returns the terminal
+ctrlrelay poller status     # verify it's running
+```
+
+Run as a supervised daemon (launchd on macOS / systemd on Linux) — see
+[Operations][ops-docs].
+
+## Documentation
+
+- [Getting started][docs-start]
+- [Configuration][docs-config]
+- [Telegram bridge][docs-bridge]
+- [Feedback loop][docs-feedback]
+- [CLI reference][docs-cli]
+- [Operations (launchd / systemd / scheduled jobs)][ops-docs]
+- [Architecture][docs-arch]
+- [Development][docs-dev]
+
+## Roadmap
+
+- **Multi-agent backend support.** The agent dispatcher is the seam we
+  intend to widen so `ctrlrelay` can drive alternative headless coding
+  agents (e.g. OpenAI Codex CLI, OpenCode, Hermes) alongside Claude
+  Code. Each backend will implement the same checkpoint protocol and
+  be selectable per repo via config.
+- **Additional scheduled jobs.** The in-process scheduler already has
+  `secops`; follow-ups include a weekly activity summary and a stale-
+  session reaper.
+- **Dashboard mode.** An optional, opt-in heartbeat push to a hosted
+  dashboard for operators running the daemon across many machines.
+
+## Contributing
+
+We welcome contributions from the community! Please read our
+[Contributing Guidelines](CONTRIBUTING.md) before submitting a pull
+request, and abide by our [Code of Conduct](CODE_OF_CONDUCT.md).
+
+First-time contributors will be prompted by the CLA Assistant bot to
+sign the Contributor Assignment Agreement in-PR — it's a one-time,
+one-comment step.
+
+## Security
+
+If you discover a security vulnerability, please follow our
+[Security Policy](SECURITY.md). Please do not file public GitHub issues
+for security reports — open a private advisory instead.
+
+## License
+
+This project is licensed under the Apache License 2.0 — see the
+[LICENSE](LICENSE) file for details.
+
+Copyright (c) 2026 AInvirion LLC. All Rights Reserved.
+
+[claude-cli]: https://docs.anthropic.com/claude/docs/claude-cli
+[gh-cli]: https://cli.github.com/
+[codex-cli]: https://github.com/openai/codex
+[docs-start]: https://ainvirion.github.io/ctrlrelay/getting-started/
+[docs-config]: https://ainvirion.github.io/ctrlrelay/configuration/
+[docs-bridge]: https://ainvirion.github.io/ctrlrelay/bridge/
+[docs-feedback]: https://ainvirion.github.io/ctrlrelay/feedback-loop/
+[docs-cli]: https://ainvirion.github.io/ctrlrelay/cli/
+[ops-docs]: https://ainvirion.github.io/ctrlrelay/operations/
+[docs-arch]: https://ainvirion.github.io/ctrlrelay/architecture/
+[docs-dev]: https://ainvirion.github.io/ctrlrelay/development/

ctrlrelay-0.1.5.dist-info/RECORD

@@ -0,0 +1,36 @@
+ctrlrelay/__init__.py,sha256=fFGk3vk282vfddBtZCBXvCV9bc5cEWu3QMgXEfkq16c,175
+ctrlrelay/cli.py,sha256=EWpqSiAfcfqcWVSqefDfph5uk301aSYUU3LTQFOgXmo,51108
+ctrlrelay/bridge/__init__.py,sha256=_xSaxU_IGHMBmdl6h3VX5PRgsI6DcGu-9COdIF_6LX0,459
+ctrlrelay/bridge/__main__.py,sha256=87DXn2Z6Wud6aA1-7NnlMolgZ99yKtWAjGJzl4kqR3w,1833
+ctrlrelay/bridge/protocol.py,sha256=9zOZp6DjIgke4JJRxc3YVDR725mbHA5-S3rGaQ33A9s,1695
+ctrlrelay/bridge/server.py,sha256=2-JCl-btyAxubPtkbHt2mJVbdNYa_CaKyMMMX6T1T_g,10211
+ctrlrelay/bridge/telegram_handler.py,sha256=YgcTO8osz5_BpzLm2JU6rneVHjpo1eSRLUm6pzpU__k,4121
+ctrlrelay/core/__init__.py,sha256=aTEJzxTqZnwuTcZotlx0HbzBOh3SqoRyeVa3r5Sa8wY,1193
+ctrlrelay/core/audit.py,sha256=Sa0QCZFgJ9bd1uSZKDHfpy_6B63SxreWDlc3iYijn8o,7068
+ctrlrelay/core/checkpoint.py,sha256=jN-UHq6pboe-LkUN20X-VCNnbuHtSnmkYjASVag87Cc,4512
+ctrlrelay/core/config.py,sha256=6Lnuy99x-RLtTlEZXDy7AmPmU8G5K3404OyO1eMup0c,9228
+ctrlrelay/core/dispatcher.py,sha256=ggDOArLnh7pfYFsSh85tvgJ0jKSMfDpysAiQFdZcm-E,6482
+ctrlrelay/core/github.py,sha256=Nf0n1elhqCoJjjYCcknnW6oGxalq6yhih0j0A9-BDFA,8370
+ctrlrelay/core/obs.py,sha256=HuqqFXe-ngxg68bMrvY4GpWTCucOjr7Qz0kpGCrpVmE,3361
+ctrlrelay/core/poller.py,sha256=DWjHMKeMeyjKgJ_MrQ1K1GgNyDIFqzBAnnQJzz0kpZk,13037
+ctrlrelay/core/pr_verifier.py,sha256=SlOMXCrwHfzmJCeisKbm4_q4P9FhdcOpRsWUEtsSOI8,7351
+ctrlrelay/core/pr_watcher.py,sha256=dsVSZ-7wnLnIyH5-sRpBkz7ExSqZn7spSGJKb90N0vE,4482
+ctrlrelay/core/scheduler.py,sha256=AoUPQ9u4YpWTD0FsROCpP65qtgu4mxiiItJtTmArgt4,13530
+ctrlrelay/core/state.py,sha256=PNcp5iIKwnkQyKMO4mjj-cVys0qmABr93lJTzj1RT7k,4681
+ctrlrelay/core/worktree.py,sha256=Ovn3aP4qVY7DT_4s199VHZhzGl0ZBTS1SKZYUDlL1nw,27495
+ctrlrelay/dashboard/__init__.py,sha256=aJtDFoW-aW7kggFfC5DCydk9QFLB2GPjaKDfcN9upBM,193
+ctrlrelay/dashboard/client.py,sha256=b7_jKy_hXTlhECvo-ZVnOwLs-6Pg73zzFLUO-3DzOmg,5015
+ctrlrelay/pipelines/__init__.py,sha256=0SwQ9d_XPTODMiiJAd2fq9B5Ya0RvSZt_iQZjHAuFUY,419
+ctrlrelay/pipelines/base.py,sha256=PJZCrA4M6sErGp5iud4K4nts3hmyU-B2ddoutXUmHU0,1144
+ctrlrelay/pipelines/dev.py,sha256=5wGHZjYaXiu0OrL1G4bi75H0kI0cexHDYXNWQMGRmq0,20981
+ctrlrelay/pipelines/post_merge.py,sha256=Ws97Tz-y7B0pX6JXq0pBmm2mX3q0-jJH0RZNQTwQ5f0,10917
+ctrlrelay/pipelines/secops.py,sha256=wp2nLRg42LYETt7BvEqpEILjBEjqCQG9EV0FQ7Cn5tQ,14124
+ctrlrelay/transports/__init__.py,sha256=W_1GeL8LzKbyK6qLOIHSc_aw2Iohj8nGlTCyxOWXz8Q,1020
+ctrlrelay/transports/base.py,sha256=cjbh1UhBXjBEbnKwlS3zJXi2R3HOx0W00CH2y1tHOoM,1199
+ctrlrelay/transports/file_mock.py,sha256=FME-k7DyszSto6IpjuPC5tsCA_bJiejQ0lSY_8yOyr4,2960
+ctrlrelay/transports/socket_client.py,sha256=YvBaXJt-Pjkcj3ayHU8NFTyUap50sKdVUwqrGwt2G-s,5975
+ctrlrelay-0.1.5.dist-info/METADATA,sha256=hRERHF5v14gfjUDlDBlVCUqMmpM9Fq7DFsMH3Lfr5Jc,10682
+ctrlrelay-0.1.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ctrlrelay-0.1.5.dist-info/entry_points.txt,sha256=OfNfO9p6j82rKledRFMzTntWWhgIbARE23OEd6UCDdU,48
+ctrlrelay-0.1.5.dist-info/licenses/LICENSE,sha256=rUu0YtwfchA4Zv96xvsR0cGxmARpqaeJOWQae5a24oA,11339
+ctrlrelay-0.1.5.dist-info/RECORD,,

ctrlrelay-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ctrlrelay-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ctrlrelay = ctrlrelay.cli:app