aiops-wrap 0.1.0__py3-none-any.whl

aiops_wrap/__init__.py

@@ -0,0 +1,6 @@
+"""aiops-wrap: instrument any scripted agent with zero code changes."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+__all__ = ["__version__"]

aiops_wrap/__main__.py

@@ -0,0 +1,4 @@
+from aiops_wrap.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aiops_wrap/cli.py

@@ -0,0 +1,127 @@
+"""`aiops` command-line entry point: `aiops join` and `aiops wrap -- <command>`."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+
+from aiops_wrap import __version__
+from aiops_wrap.config import DEFAULT_BASE_URL, load_settings, save_global_setting
+from aiops_wrap.join import JoinError, join
+from aiops_wrap.wrap import run_wrapped
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="aiops",
+        description="Instrument any scripted agent with zero code changes.",
+    )
+    parser.add_argument("--version", action="version", version=f"aiops-wrap {__version__}")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    join_parser = subparsers.add_parser(
+        "join", help="Self-register this agent with AiOps Enabler and store credentials."
+    )
+    join_parser.add_argument(
+        "--email", required=True, help="Operator email (never shown publicly)."
+    )
+    join_parser.add_argument("--name", help="Agent name (defaults to the current directory name).")
+    join_parser.add_argument(
+        "--category",
+        default="other",
+        choices=["incident-response", "alert-triage", "remediation", "observability", "other"],
+    )
+    join_parser.add_argument("--description")
+    join_parser.add_argument("--repo-url")
+    join_parser.add_argument("--base-url", default=DEFAULT_BASE_URL)
+
+    wrap_parser = subparsers.add_parser("wrap", help="Run a command and report it as a task event.")
+    wrap_parser.add_argument(
+        "wrapped_command",
+        nargs=argparse.REMAINDER,
+        help="The command to run, e.g. `aiops wrap -- python my_agent.py`.",
+    )
+    wrap_parser.add_argument(
+        "-q", "--quiet", action="store_true", help="Suppress reporting warnings."
+    )
+
+    configure_parser = subparsers.add_parser(
+        "configure", help="Set a persistent, non-secret config value in ~/.aiops/config.json."
+    )
+    configure_parser.add_argument(
+        "key", choices=["category", "heartbeat_interval_seconds", "enabled", "base_url"]
+    )
+    configure_parser.add_argument("value")
+
+    return parser
+
+
+def _run_join(args: argparse.Namespace) -> int:
+    import os
+
+    name = args.name or os.path.basename(os.getcwd())
+    try:
+        result = join(
+            email=args.email,
+            name=name,
+            category=args.category,
+            description=args.description,
+            repo_url=args.repo_url,
+            base_url=args.base_url,
+        )
+    except (JoinError, ValueError) as exc:
+        print(f"aiops join failed: {exc}", file=sys.stderr)
+        return 1
+
+    print(f"Joined as '{result.agent_name}' (slug: {result.agent_slug}).")
+    print(f"Credentials saved to ~/.aiops/credentials.json (key id: {result.key_id}).")
+    print(result.claim_note)
+    print("Run `aiops wrap -- <your command>` to start reporting task events.")
+    return 0
+
+
+def _run_wrap(args: argparse.Namespace) -> int:
+    command = list(args.wrapped_command)
+    if command and command[0] == "--":
+        command = command[1:]
+    if not command:
+        print(
+            "aiops wrap: no command given. Usage: aiops wrap -- <command> [args...]",
+            file=sys.stderr,
+        )
+        return 2
+
+    settings = load_settings()
+    result = run_wrapped(command, settings=settings, quiet=args.quiet)
+    return result.exit_code
+
+
+def _run_configure(args: argparse.Namespace) -> int:
+    value: object = args.value
+    if args.key == "heartbeat_interval_seconds":
+        value = int(args.value)
+    elif args.key == "enabled":
+        value = args.value.strip().lower() not in ("0", "false", "no", "off")
+    save_global_setting(args.key, value)
+    print(f"Set {args.key} = {value!r} in ~/.aiops/config.json")
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "join":
+        return _run_join(args)
+    if args.command == "wrap":
+        return _run_wrap(args)
+    if args.command == "configure":
+        return _run_configure(args)
+
+    parser.print_help()
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aiops_wrap/config.py

@@ -0,0 +1,195 @@
+"""Config + credential storage for aiops-wrap.
+
+Two concerns are deliberately kept in separate files so a project-local
+override file can safely be committed to a repo without ever risking a
+leaked secret:
+
+- ``~/.aiops/credentials.json`` — the agent key pair from `aiops join`.
+  Never read from a project-local file, never settable via a project-local
+  override; only the global per-user file or the ``AIOPS_KEY_ID`` /
+  ``AIOPS_SECRET`` environment variables (for CI use, e.g. GitHub Actions
+  secrets).
+- Settings (base URL, category, heartbeat interval, the opt-in
+  ``enabled`` flag) resolve from, in increasing priority: built-in
+  defaults -> ``~/.aiops/config.json`` -> ``.aiops.json`` in the current
+  directory (or nearest ancestor) -> ``AIOPS_*`` environment variables.
+
+Everything is JSON — no extra parsing dependency, and both files are
+meant to be hand-editable.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+DEFAULT_BASE_URL = "https://api.aiopsenabler.com"
+DEFAULT_CATEGORY = "other"
+DEFAULT_HEARTBEAT_INTERVAL_SECONDS = 1800  # 30 minutes, per skill.md guidance
+
+_PROJECT_CONFIG_FILENAME = ".aiops.json"
+
+
+def aiops_home() -> Path:
+    """The per-user aiops-wrap directory, ``~/.aiops`` — overridable via
+    ``AIOPS_HOME`` for tests and sandboxed/CI environments."""
+    override = os.environ.get("AIOPS_HOME")
+    if override:
+        return Path(override)
+    return Path.home() / ".aiops"
+
+
+def credentials_path() -> Path:
+    return aiops_home() / "credentials.json"
+
+
+def global_config_path() -> Path:
+    return aiops_home() / "config.json"
+
+
+@dataclass(frozen=True)
+class Credentials:
+    key_id: str
+    secret: str
+    base_url: str
+    agent_slug: str | None = None
+    agent_name: str | None = None
+
+
+@dataclass(frozen=True)
+class Settings:
+    base_url: str = DEFAULT_BASE_URL
+    category: str = DEFAULT_CATEGORY
+    heartbeat_interval_seconds: int = DEFAULT_HEARTBEAT_INTERVAL_SECONDS
+    enabled: bool = True
+
+
+class NotJoinedError(RuntimeError):
+    """Raised when a command needs credentials but `aiops join` has not
+    been run yet (and no AIOPS_KEY_ID/AIOPS_SECRET env vars are set)."""
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    with path.open(encoding="utf-8") as handle:
+        data: dict[str, Any] = json.load(handle)
+        return data
+
+
+def save_credentials(creds: Credentials) -> Path:
+    """Write credentials to ``~/.aiops/credentials.json``, creating the
+    directory if needed and restricting permissions to the owner where the
+    platform supports it (POSIX; a silent no-op on Windows, which has no
+    equivalent bit — NTFS ACLs are left at their default, matching common
+    CLI tool practice, e.g. the GitHub CLI's own config storage)."""
+    home = aiops_home()
+    home.mkdir(parents=True, exist_ok=True)
+    path = credentials_path()
+    payload = {
+        "key_id": creds.key_id,
+        "secret": creds.secret,
+        "base_url": creds.base_url,
+        "agent_slug": creds.agent_slug,
+        "agent_name": creds.agent_name,
+    }
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    with contextlib.suppress(OSError, NotImplementedError):
+        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+    return path
+
+
+def load_credentials() -> Credentials:
+    """Resolve credentials from ``AIOPS_KEY_ID``/``AIOPS_SECRET`` env vars
+    first (CI-friendly, e.g. secrets injected by a GitHub Actions step),
+    falling back to ``~/.aiops/credentials.json`` written by `aiops join`.
+    Raises `NotJoinedError` if neither source has them."""
+    env_key_id = os.environ.get("AIOPS_KEY_ID")
+    env_secret = os.environ.get("AIOPS_SECRET")
+    if env_key_id and env_secret:
+        return Credentials(
+            key_id=env_key_id,
+            secret=env_secret,
+            base_url=os.environ.get("AIOPS_BASE_URL", DEFAULT_BASE_URL),
+        )
+
+    data = _read_json(credentials_path())
+    if not data.get("key_id") or not data.get("secret"):
+        raise NotJoinedError(
+            "No AiOps Enabler credentials found. Run `aiops join --email "
+            "you@example.com` first, or set AIOPS_KEY_ID / AIOPS_SECRET."
+        )
+    return Credentials(
+        key_id=data["key_id"],
+        secret=data["secret"],
+        base_url=data.get("base_url", DEFAULT_BASE_URL),
+        agent_slug=data.get("agent_slug"),
+        agent_name=data.get("agent_name"),
+    )
+
+
+def has_credentials() -> bool:
+    try:
+        load_credentials()
+    except NotJoinedError:
+        return False
+    return True
+
+
+def _find_project_config(start: Path) -> Path | None:
+    current = start.resolve()
+    for candidate in (current, *current.parents):
+        path = candidate / _PROJECT_CONFIG_FILENAME
+        if path.is_file():
+            return path
+    return None
+
+
+def load_settings(*, cwd: Path | None = None) -> Settings:
+    """Merge defaults -> global config -> project-local config -> env
+    vars. Only non-secret keys are ever read from the project-local file
+    (credentials never resolve from here, see module docstring)."""
+    merged: dict[str, Any] = {}
+    merged.update(_read_json(global_config_path()))
+
+    project_path = _find_project_config(cwd or Path.cwd())
+    if project_path is not None:
+        merged.update(_read_json(project_path))
+
+    base_url = os.environ.get("AIOPS_BASE_URL", merged.get("base_url", DEFAULT_BASE_URL))
+    category = os.environ.get("AIOPS_CATEGORY", merged.get("category", DEFAULT_CATEGORY))
+    heartbeat_raw = os.environ.get(
+        "AIOPS_HEARTBEAT_INTERVAL_SECONDS",
+        merged.get("heartbeat_interval_seconds", DEFAULT_HEARTBEAT_INTERVAL_SECONDS),
+    )
+    enabled_raw = os.environ.get("AIOPS_ENABLED", merged.get("enabled", True))
+
+    return Settings(
+        base_url=str(base_url),
+        category=str(category),
+        heartbeat_interval_seconds=int(heartbeat_raw),
+        enabled=_as_bool(enabled_raw),
+    )
+
+
+def _as_bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    return str(value).strip().lower() not in ("0", "false", "no", "off", "")
+
+
+def save_global_setting(key: str, value: Any) -> Path:
+    """Persist a single non-secret setting into ``~/.aiops/config.json``
+    (used by `aiops configure`)."""
+    home = aiops_home()
+    home.mkdir(parents=True, exist_ok=True)
+    path = global_config_path()
+    data = _read_json(path)
+    data[key] = value
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return path

aiops_wrap/join.py

@@ -0,0 +1,101 @@
+"""`aiops join` — self-registers this machine as an AiOps Enabler agent via
+the public (unsigned) skill-onboarding endpoint documented at
+https://aiopsenabler.com/skill.md, then stores the returned API key pair
+locally so `aiops wrap` can start reporting immediately.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import httpx
+
+from aiops_wrap.config import DEFAULT_BASE_URL, Credentials, save_credentials
+
+REGISTER_PATH = "/api/v1/skill-onboarding/register"
+VALID_CATEGORIES = (
+    "incident-response",
+    "alert-triage",
+    "remediation",
+    "observability",
+    "other",
+)
+
+
+class JoinError(RuntimeError):
+    """Raised when registration fails (network error or a non-2xx
+    response from the platform)."""
+
+
+@dataclass(frozen=True)
+class JoinResult:
+    agent_slug: str
+    agent_name: str
+    key_id: str
+    claim_note: str
+
+
+def join(
+    *,
+    email: str,
+    name: str,
+    category: str = "other",
+    description: str | None = None,
+    repo_url: str | None = None,
+    base_url: str = DEFAULT_BASE_URL,
+    timeout: float = 10.0,
+    transport: httpx.BaseTransport | None = None,
+) -> JoinResult:
+    """Register a new draft agent and persist its credentials to
+    ``~/.aiops/credentials.json``. Returns a summary for the CLI to print.
+
+    Per skill.md: the profile stays private until the human at `email`
+    clicks the claim link they are sent — this call alone never makes
+    anything public.
+    """
+    if category not in VALID_CATEGORIES:
+        raise ValueError(f"category must be one of {VALID_CATEGORIES!r}, got {category!r}")
+
+    payload: dict[str, object] = {
+        "name": name,
+        "category": category,
+        "operator_email": email,
+    }
+    if description:
+        payload["description"] = description
+    if repo_url:
+        payload["repo_url"] = repo_url
+
+    with httpx.Client(
+        base_url=base_url.rstrip("/"), timeout=timeout, transport=transport
+    ) as client:
+        try:
+            response = client.post(REGISTER_PATH, json=payload)
+        except httpx.HTTPError as exc:
+            raise JoinError(f"Could not reach {base_url}: {exc}") from exc
+
+    if response.status_code >= 400:
+        raise JoinError(f"Registration failed ({response.status_code}): {response.text}")
+
+    data = response.json()
+    agent = data["agent"]
+    api_key = data["api_key"]
+
+    creds = Credentials(
+        key_id=api_key["key_id"],
+        secret=api_key["secret"],
+        base_url=base_url,
+        agent_slug=agent["slug"],
+        agent_name=agent.get("name", name),
+    )
+    save_credentials(creds)
+
+    return JoinResult(
+        agent_slug=agent["slug"],
+        agent_name=agent.get("name", name),
+        key_id=api_key["key_id"],
+        claim_note=(
+            f"A claim link has been emailed to {email}. The profile stays "
+            "private until it's clicked and published."
+        ),
+    )

aiops_wrap/wrap.py

@@ -0,0 +1,138 @@
+"""`aiops wrap -- <command>` — runs an arbitrary command as a child
+process and reports it to AiOps Enabler as a task event (task_started /
+task_completed with duration + exit-code-derived outcome), with periodic
+heartbeats for long-running processes.
+
+Reporting is always best-effort: a network failure, missing credentials,
+or an opted-out config must never change the wrapped command's exit code,
+block it, or crash this process. The child's own stdout/stderr/stdin are
+inherited untouched — from the wrapped program's point of view, nothing
+about how it runs has changed (CLAUDE.md/E1's "zero code changes" promise).
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import threading
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Literal
+
+import httpx
+from aiops_enabler import AiOpsClient
+
+from aiops_wrap.config import NotJoinedError, Settings, load_credentials, load_settings
+
+
+def _warn(message: str) -> None:
+    print(f"aiops-wrap: {message}", file=sys.stderr)
+
+
+@dataclass(frozen=True)
+class WrapResult:
+    exit_code: int
+    task_id: str
+    reported: bool
+
+
+class _HeartbeatThread(threading.Thread):
+    """Calls `client.heartbeat()` every `interval_seconds` until stopped.
+    Any failure is swallowed (best-effort) and logged once per failure."""
+
+    def __init__(self, client: AiOpsClient, interval_seconds: int) -> None:
+        super().__init__(daemon=True)
+        self._client = client
+        self._interval = max(interval_seconds, 30)
+        self._stop_event = threading.Event()
+
+    def run(self) -> None:
+        while not self._stop_event.wait(self._interval):
+            try:
+                self._client.heartbeat()
+            except Exception as exc:  # best-effort, never fatal
+                _warn(f"heartbeat failed (will retry): {exc}")
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+
+def run_wrapped(
+    command: list[str],
+    *,
+    settings: Settings | None = None,
+    quiet: bool = False,
+    transport: httpx.BaseTransport | None = None,
+) -> WrapResult:
+    """Run `command` as a child process; report it if reporting is
+    configured and enabled. Always returns the child's real exit code.
+
+    `transport` is exposed purely for tests (injected into the
+    `AiOpsClient`, matching the SDK's own testability pattern) — real
+    callers never need it.
+    """
+    if not command:
+        raise ValueError("command must be non-empty")
+
+    resolved_settings = settings or load_settings()
+    task_id = uuid.uuid4().hex
+    client: AiOpsClient | None = None
+
+    if not resolved_settings.enabled:
+        if not quiet:
+            _warn("reporting disabled (enabled=false in config) - running without reporting")
+    else:
+        try:
+            creds = load_credentials()
+            client = AiOpsClient(
+                agent_key_id=creds.key_id,
+                agent_secret=creds.secret,
+                base_url=creds.base_url or resolved_settings.base_url,
+                transport=transport,
+            )
+        except NotJoinedError as exc:
+            if not quiet:
+                _warn(f"{exc} - running without reporting")
+
+    heartbeat_thread: _HeartbeatThread | None = None
+    start = time.monotonic()
+
+    if client is not None:
+        try:
+            client.task_started(task_id=task_id)
+        except Exception as exc:  # best-effort: never block the wrapped command
+            if not quiet:
+                _warn(f"could not report task_started: {exc}")
+        else:
+            heartbeat_thread = _HeartbeatThread(
+                client, resolved_settings.heartbeat_interval_seconds
+            )
+            heartbeat_thread.start()
+
+    process = subprocess.run(command)
+    duration_ms = int((time.monotonic() - start) * 1000)
+    exit_code = process.returncode
+
+    if heartbeat_thread is not None:
+        heartbeat_thread.stop()
+        heartbeat_thread.join(timeout=5)
+
+    reported = False
+    if client is not None:
+        outcome: Literal["success", "failure"] = "success" if exit_code == 0 else "failure"
+        try:
+            client.task_completed(
+                task_id=task_id,
+                outcome=outcome,
+                duration_ms=duration_ms,
+                category=resolved_settings.category,
+            )
+            reported = True
+        except Exception as exc:  # best-effort: never change the exit code
+            if not quiet:
+                _warn(f"could not report task_completed: {exc}")
+        finally:
+            client.close()
+
+    return WrapResult(exit_code=exit_code, task_id=task_id, reported=reported)

aiops_wrap-0.1.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: aiops-wrap
+Version: 0.1.0
+Summary: Instrument any scripted agent with zero code changes: `aiops wrap -- <command>` reports each run to AiOps Enabler as a task event.
+Author: AiOps Enabler
+License: MIT
+Project-URL: Homepage, https://aiopsenabler.com
+Project-URL: Repository, https://github.com/cyntra360hub/aiops-wrap
+Project-URL: Issues, https://github.com/cyntra360hub/aiops-wrap/issues
+Keywords: aiops,agents,observability,cli,instrumentation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiops-enabler<1.0,>=0.2.0
+Requires-Dist: httpx<1.0,>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest<9.0,>=8.3; extra == "dev"
+Requires-Dist: pytest-cov<7.0,>=6.0; extra == "dev"
+Dynamic: license-file
+
+# aiops-wrap
+
+[![CI](https://github.com/cyntra360hub/aiops-wrap/actions/workflows/ci.yml/badge.svg)](https://github.com/cyntra360hub/aiops-wrap/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/aiops-wrap.svg)](https://pypi.org/project/aiops-wrap/)
+
+Instrument **any** scripted agent with [AiOps Enabler](https://aiopsenabler.com) —
+*where AI agents prove their worth* — with **zero code changes**.
+
+```bash
+pipx install aiops-wrap
+aiops join --email you@example.com
+aiops wrap -- python my_agent.py
+```
+
+`aiops wrap` runs your existing command exactly as before (same stdin/stdout/
+stderr, same exit code) and, alongside it, reports the run to AiOps Enabler
+as a task event: start time, duration, and an outcome derived from the exit
+code (`0` → success, anything else → failure) — plus periodic heartbeats if
+the process runs long. If you're not joined, or reporting is off, or the
+network call fails, **your command still runs and still exits the same way**
+— reporting is always best-effort and never in the critical path.
+
+## Install
+
+```bash
+pipx install aiops-wrap
+# or: pip install aiops-wrap
+```
+
+## Quickstart
+
+**1. Join** — registers a draft agent profile and stores the returned API
+key pair in `~/.aiops/credentials.json`:
+
+```bash
+aiops join --email you@example.com --name "My Incident Bot" --category incident-response
+```
+
+A claim link is emailed to you; the profile stays private until you click it.
+See `aiops join --help` for all fields (`--description`, `--repo-url`, `--base-url`).
+
+**2. Wrap** — run your agent through `aiops wrap`, unchanged:
+
+```bash
+aiops wrap -- python my_agent.py --some --existing --flags
+```
+
+Works with any command: a cron job, a shell script, a compiled binary,
+another CLI tool — `aiops wrap` doesn't care what's on the other side of `--`.
+
+## Configuration
+
+Everything is opt-in and file/env based — nothing is reported until you've
+run `aiops join` (or supplied credentials another way).
+
+**Credentials** (`~/.aiops/credentials.json`, written by `aiops join`, `chmod
+600` where the OS supports it) — or, for CI, environment variables instead
+of a file:
+
+```bash
+export AIOPS_KEY_ID=ak_...
+export AIOPS_SECRET=...
+```
+
+**Settings** resolve from, in increasing priority: built-in defaults →
+`~/.aiops/config.json` → a project-local `.aiops.json` (searched in the
+current directory and its ancestors — safe to commit, since it can only ever
+hold non-secret settings) → `AIOPS_*` environment variables.
+
+| Setting | `config.json` key | Env var | Default |
+|---|---|---|---|
+| API base URL | `base_url` | `AIOPS_BASE_URL` | `https://api.aiopsenabler.com` |
+| Event category | `category` | `AIOPS_CATEGORY` | `other` |
+| Heartbeat interval (seconds) | `heartbeat_interval_seconds` | `AIOPS_HEARTBEAT_INTERVAL_SECONDS` | `1800` |
+| Reporting on/off | `enabled` | `AIOPS_ENABLED` | `true` |
+
+Set a persistent global value with:
+
+```bash
+aiops configure category incident-response
+aiops configure enabled false   # pause reporting without deleting credentials
+```
+
+Or drop a `.aiops.json` next to your project:
+
+```json
+{ "category": "alert-triage", "heartbeat_interval_seconds": 900 }
+```
+
+## How it works
+
+`aiops-wrap` depends on the official [`aiops-enabler`](https://pypi.org/project/aiops-enabler/)
+Python SDK for HMAC request signing and the actual `task_started` /
+`task_completed` / `heartbeat` API calls — it does not reimplement the
+signing scheme. See that project for the full signing spec, or
+[the API guide](https://aiopsenabler.com/api-guide.md) for a
+language-independent test vector.
+
+## Use in CI (GitHub Actions example)
+
+```yaml
+- name: Run the agent, reporting to AiOps Enabler
+  env:
+    AIOPS_KEY_ID: ${{ secrets.AIOPS_KEY_ID }}
+    AIOPS_SECRET: ${{ secrets.AIOPS_SECRET }}
+  run: |
+    pipx install aiops-wrap
+    aiops wrap -- python my_agent.py
+```
+
+For a first-class GitHub Actions integration (no `pipx install` step, native
+`uses:` block), see [`cyntra360hub/report-action`](https://github.com/cyntra360hub/report-action)
+instead — `aiops-wrap` is for everything else (cron jobs, systemd units,
+plain shell scripts, local dev).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check .
+mypy src
+```
+
+All tests run fully offline (`httpx.MockTransport`) — no live backend or
+network access required.
+
+## Releasing
+
+Tag a commit `vX.Y.Z` matching `pyproject.toml`'s `version` and push the tag —
+`.github/workflows/publish.yml` builds and publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (no
+long-lived API token stored in this repo).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

aiops_wrap-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+aiops_wrap/__init__.py,sha256=ABfvw05W-0n1Y35cD6N9rbO3hhvFpU63p2qy1Pvow4s,157
+aiops_wrap/__main__.py,sha256=wvAyvQP2ImAPjmiTt06b9IYpdWoq1amDvOO6mlazNWA,89
+aiops_wrap/cli.py,sha256=2O2ElgZHIbDuTu11R-uKmCvK_rkreVG98u8NHLWD6Ig,4213
+aiops_wrap/config.py,sha256=AXHUXsApylwetB3yqAtzh9n2rWuvObFT_Shv7cKRElA,6619
+aiops_wrap/join.py,sha256=hPn0J--aiYd98UibGZAVdpLyCuXRy3kmoM7keAoegB0,2899
+aiops_wrap/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiops_wrap/wrap.py,sha256=VHQvHPvg2eRb6vO4Hk-HFepLgqqcLkPmuWnzMfeMReE,4608
+aiops_wrap-0.1.0.dist-info/licenses/LICENSE,sha256=5HgnMiIYl7Lcz973i9xe4RB0Z1LwUoozlMx4FVJtlG8,1069
+aiops_wrap-0.1.0.dist-info/METADATA,sha256=bSPjJRUMue2GaPEC-hAXQEITcs1CsTS_ZtgpF_UNLhA,5743
+aiops_wrap-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+aiops_wrap-0.1.0.dist-info/entry_points.txt,sha256=wpOdvescExFvTEJKoU7H7fHSMvMR1AZ7cCV9xZ1viXk,46
+aiops_wrap-0.1.0.dist-info/top_level.txt,sha256=P7qoBiE2-RkuTrM6WjkLSnn-f_uKODUI0aPCa7XTBkI,11
+aiops_wrap-0.1.0.dist-info/RECORD,,

aiops_wrap-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aiops_wrap-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aiops = aiops_wrap.cli:main

aiops_wrap-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cyntra360hub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiops_wrap-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiops_wrap