queue-aiops 0.1.0__py3-none-any.whl

queue_aiops/secretstore.py

@@ -0,0 +1,304 @@
+"""Encrypted secret storage for queue-aiops.
+
+Secrets (redis / rabbitmq passwords) are NEVER written to disk in plaintext. They
+live in ``~/.queue-aiops/secrets.enc`` encrypted with Fernet (AES-128-CBC +
+HMAC-SHA256). The Fernet key is derived from a master password via scrypt —
+the password itself is never stored; only a random per-store salt and the
+ciphertext are on disk.
+
+The master password is resolved (in order) from:
+
+  1. the env var ``QUEUE_AIOPS_MASTER_PASSWORD`` (for non-interactive use:
+     the MCP server, CI, cron), or
+  2. an interactive ``getpass`` prompt (CLI on a TTY).
+
+This module is deliberately self-contained (no skill-family imports) so it can
+be vendored per tool exactly like the governance harness. To adapt it for
+another tool, change the three constants below.
+
+Design rules honoured here:
+  * Immutability — the decrypted secret map is never mutated in place; every
+    ``set``/``delete`` derives a new dict and re-encrypts it.
+  * Fail fast with teaching errors at the trust boundary.
+  * Owner-only files (chmod 600 on the blob, 700 on the dir).
+"""
+
+from __future__ import annotations
+
+import base64
+import getpass
+import json
+import logging
+import os
+import stat
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from cryptography.exceptions import InvalidKey
+from cryptography.fernet import Fernet, InvalidToken
+from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
+
+from queue_aiops.governance.paths import ops_home
+
+# ─── Tool-specific constants (change these three to vendor for another tool) ──
+APP_NAME = "queue-aiops"
+CONFIG_DIR = ops_home()
+MASTER_PASSWORD_ENV = "QUEUE_AIOPS_MASTER_PASSWORD"  # nosec B105 — env-var name
+# ──────────────────────────────────────────────────────────────────────────────
+
+SECRETS_FILE = CONFIG_DIR / "secrets.enc"
+LEGACY_ENV_FILE = CONFIG_DIR / ".env"
+
+# scrypt work factors (RFC 7914). N must be a power of two; these give ~100ms
+# on commodity hardware in 2026 — strong for an interactive unlock, cheap
+# enough to run once per process.
+_SCRYPT_N = 2**15
+_SCRYPT_R = 8
+_SCRYPT_P = 1
+_KEY_LEN = 32
+_SALT_LEN = 16
+_FORMAT_VERSION = 1
+
+_log = logging.getLogger(f"{APP_NAME}.secretstore")
+
+
+class SecretStoreError(Exception):
+    """A secret could not be stored or retrieved; carries a teaching message."""
+
+
+class MasterPasswordError(SecretStoreError):
+    """The master password is missing or wrong."""
+
+
+def _derive_key(password: str, salt: bytes) -> bytes:
+    """Derive a urlsafe-base64 Fernet key from a password + salt via scrypt."""
+    kdf = Scrypt(salt=salt, length=_KEY_LEN, n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P)
+    raw = kdf.derive(password.encode("utf-8"))
+    return base64.urlsafe_b64encode(raw)
+
+
+def _chmod_600(path: Path) -> None:
+    try:
+        path.chmod(0o600)
+    except OSError:  # best effort on exotic filesystems
+        pass
+
+
+def _ensure_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        CONFIG_DIR.chmod(0o700)
+    except OSError:
+        pass
+
+
+def resolve_master_password(*, confirm_if_new: bool = False) -> str:
+    """Resolve the master password from env or an interactive prompt.
+
+    ``confirm_if_new`` asks twice when no store exists yet (set-up flow).
+    Raises ``MasterPasswordError`` when no password is available and there is no
+    TTY to prompt on (e.g. an MCP server started without the env var).
+    """
+    env_value = os.environ.get(MASTER_PASSWORD_ENV)
+    if env_value:
+        return env_value
+
+    if not sys.stdin.isatty():
+        raise MasterPasswordError(
+            f"Master password not set. Export {MASTER_PASSWORD_ENV} (the password "
+            f"that unlocks {SECRETS_FILE}) before running non-interactively, or "
+            f"run '{APP_NAME} init' on a terminal to set up secrets."
+        )
+
+    store_exists = SECRETS_FILE.exists()
+    prompt = f"Master password for {APP_NAME}: "
+    password = getpass.getpass(prompt)
+    if not password:
+        raise MasterPasswordError("Empty master password is not allowed.")
+    if confirm_if_new and not store_exists:
+        again = getpass.getpass("Confirm master password: ")
+        if again != password:
+            raise MasterPasswordError("Passwords did not match. Aborted.")
+    return password
+
+
+@dataclass(frozen=True)
+class SecretStore:
+    """An unlocked view over the encrypted secret file.
+
+    Construct via :meth:`unlock` (or :func:`open_store`). The decrypted map is
+    held in memory only; every mutation returns a *new* ``SecretStore`` after
+    re-encrypting to disk — instances are immutable.
+    """
+
+    _password: str
+    _salt: bytes
+    _data: dict[str, str]
+
+    # ── factory ────────────────────────────────────────────────────────────
+    @classmethod
+    def unlock(cls, password: str | None = None) -> SecretStore:
+        """Open (or initialise) the store, decrypting with ``password``."""
+        pw = password if password is not None else resolve_master_password()
+        if not SECRETS_FILE.exists():
+            return cls(_password=pw, _salt=os.urandom(_SALT_LEN), _data={})
+
+        try:
+            raw = json.loads(SECRETS_FILE.read_text("utf-8"))
+        except (OSError, ValueError) as exc:
+            raise SecretStoreError(
+                f"Could not read secret store {SECRETS_FILE}: {exc}"
+            ) from exc
+
+        if raw.get("version") != _FORMAT_VERSION:
+            raise SecretStoreError(
+                f"Unsupported secret store version {raw.get('version')!r} in "
+                f"{SECRETS_FILE}; expected {_FORMAT_VERSION}."
+            )
+        salt = base64.b64decode(raw["salt"])
+        token = raw["ciphertext"].encode("ascii")
+        try:
+            key = _derive_key(pw, salt)
+            plaintext = Fernet(key).decrypt(token)
+        except (InvalidToken, InvalidKey, ValueError) as exc:
+            raise MasterPasswordError(
+                "Wrong master password (could not decrypt the secret store). "
+                f"If you forgot it, delete {SECRETS_FILE} and re-run "
+                f"'{APP_NAME} init' to re-enter credentials."
+            ) from exc
+        data = json.loads(plaintext.decode("utf-8"))
+        return cls(_password=pw, _salt=salt, _data=dict(data))
+
+    # ── read ──────────────────────────────────────────────────────────────
+    def get(self, name: str) -> str:
+        try:
+            return self._data[name]
+        except KeyError as exc:
+            available = ", ".join(sorted(self._data)) or "(none)"
+            raise SecretStoreError(
+                f"No secret stored for '{name}'. Stored: {available}. "
+                f"Add one with '{APP_NAME} secret set {name}'."
+            ) from exc
+
+    def names(self) -> tuple[str, ...]:
+        return tuple(sorted(self._data))
+
+    def __contains__(self, name: object) -> bool:
+        return name in self._data
+
+    # ── write (returns a new immutable store) ──────────────────────────────
+    def set(self, name: str, value: str) -> SecretStore:
+        if not name:
+            raise SecretStoreError("Secret name must not be empty.")
+        if not value:
+            raise SecretStoreError("Secret value must not be empty.")
+        new_data = {**self._data, name: value}
+        new_store = SecretStore(_password=self._password, _salt=self._salt, _data=new_data)
+        new_store._persist()
+        return new_store
+
+    def delete(self, name: str) -> SecretStore:
+        if name not in self._data:
+            raise SecretStoreError(f"No secret named '{name}' to delete.")
+        new_data = {k: v for k, v in self._data.items() if k != name}
+        new_store = SecretStore(_password=self._password, _salt=self._salt, _data=new_data)
+        new_store._persist()
+        return new_store
+
+    def with_password(self, new_password: str) -> SecretStore:
+        """Re-encrypt all secrets under a new master password (rotation)."""
+        if not new_password:
+            raise SecretStoreError("New master password must not be empty.")
+        new_store = SecretStore(
+            _password=new_password, _salt=os.urandom(_SALT_LEN), _data=dict(self._data)
+        )
+        new_store._persist()
+        return new_store
+
+    # ── persistence ────────────────────────────────────────────────────────
+    def _persist(self) -> None:
+        _ensure_dir()
+        key = _derive_key(self._password, self._salt)
+        token = Fernet(key).encrypt(json.dumps(self._data).encode("utf-8"))
+        blob = json.dumps(
+            {
+                "version": _FORMAT_VERSION,
+                "salt": base64.b64encode(self._salt).decode("ascii"),
+                "ciphertext": token.decode("ascii"),
+            },
+            indent=2,
+        )
+        tmp = SECRETS_FILE.with_suffix(".enc.tmp")
+        tmp.write_text(blob, "utf-8")
+        _chmod_600(tmp)
+        tmp.replace(SECRETS_FILE)
+        _chmod_600(SECRETS_FILE)
+
+
+# ─── module-level convenience API (the rest of the app uses these) ───────────
+
+_cached: SecretStore | None = None
+
+
+def open_store(password: str | None = None, *, use_cache: bool = True) -> SecretStore:
+    """Return an unlocked store, caching it for the process when possible."""
+    global _cached  # noqa: PLW0603
+    if use_cache and _cached is not None and password is None:
+        return _cached
+    store = SecretStore.unlock(password)
+    if use_cache and password is None:
+        _cached = store
+    return store
+
+
+def get_secret(name: str) -> str:
+    """Look up a secret by name, unlocking the store on first use."""
+    return open_store().get(name)
+
+
+def has_store() -> bool:
+    return SECRETS_FILE.exists()
+
+
+def check_permissions() -> str | None:
+    """Return a warning string if ``secrets.enc`` is group/world-accessible."""
+    if not SECRETS_FILE.exists():
+        return None
+    mode = SECRETS_FILE.stat().st_mode
+    if mode & (stat.S_IRWXG | stat.S_IRWXO):
+        return (
+            f"{SECRETS_FILE} has permissions {oct(stat.S_IMODE(mode))} "
+            f"(should be 600). Run: chmod 600 {SECRETS_FILE}"
+        )
+    return None
+
+
+def migrate_legacy_env(prefix: str, suffix: str, password: str | None = None) -> list[str]:
+    """Import plaintext ``.env`` secrets into the encrypted store.
+
+    Legacy keys look like ``QUEUE_<TARGET>_SECRET``; ``prefix='QUEUE_'`` and
+    ``suffix='_PASSWORD'`` map them back to a target name. The plaintext
+    ``.env`` is renamed to ``.env.migrated`` (chmod 600) so nothing is silently
+    lost. Returns the list of imported target names.
+    """
+    if not LEGACY_ENV_FILE.exists():
+        return []
+    imported: list[str] = []
+    store = SecretStore.unlock(password)
+    for line in LEGACY_ENV_FILE.read_text("utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip().strip("'\"")
+        if not (key.startswith(prefix) and key.endswith(suffix) and value):
+            continue
+        target = key[len(prefix) : -len(suffix)].lower().replace("_", "-")
+        store = store.set(target, value)
+        imported.append(target)
+    if imported:
+        backup = LEGACY_ENV_FILE.with_name(".env.migrated")
+        LEGACY_ENV_FILE.replace(backup)
+        _chmod_600(backup)
+    return imported

queue_aiops-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: queue-aiops
+Version: 0.1.0
+Summary: Governed AI-ops for redis + rabbitmq: memory-pressure/latency/queue-backlog/connection-churn RCAs, slowlog and SCAN-budgeted big-key sampling, queues/policies/nodes, and governed writes (config set, client kill, purge/delete queue, policies) with a built-in governance harness (audit, budget, undo, risk tiers)
+Author-email: wei <zhouwei008@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=42.0
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: mcp[cli]<2.0,>=1.10
+Requires-Dist: pyyaml<7.0,>=6.0
+Requires-Dist: redis<7.0,>=5.0
+Requires-Dist: rich<16.0,>=13.0
+Requires-Dist: typer<1.0,>=0.12
+Description-Content-Type: text/markdown
+
+# Queue AIops (preview)
+
+**Governed AI-ops for redis + rabbitmq.** queue-aiops is for the team running
+their own cache and message broker — a redis that "suddenly eats memory", a
+rabbitmq whose queues quietly grow until publishers block — without an
+enterprise observability suite. It gives an AI agent (or a human at the CLI) a
+governed toolset over both: transparent root-cause analyses for memory
+pressure, latency, queue backlog, and connection churn, plus the handful of
+writes an operator actually needs (config set, client kill, purge/delete
+queue, policies) — every call audited, budgeted, risk-tiered, and undo-recorded
+by the built-in governance harness.
+
+> **Disclaimer**: Community-maintained open-source project, **not affiliated
+> with, endorsed by, or sponsored by the Redis or RabbitMQ projects or their
+> respective owners.** Redis and RabbitMQ are trademarks of their respective owners.
+>
+> **Preview / mock-only**: not yet validated against production brokers. Both
+> redis and rabbitmq are free/self-hostable (one lab container or package install each), so a lab
+> check is easy — `queue-aiops doctor` is the fastest live probe.
+
+## Quick start
+
+```bash
+uv tool install queue-aiops
+
+queue-aiops init      # wizard: pick platform (redis/rabbitmq), host/port, encrypted secret
+queue-aiops doctor    # config + secret + connectivity check (PING / /api/overview)
+queue-aiops overview  # one-shot health summary for the default target
+```
+
+Then the interesting parts:
+
+```bash
+queue-aiops analyze memory     # redis memory-pressure RCA (maxmemory, eviction, frag, big keys)
+queue-aiops analyze latency    # redis latency RCA (slowlog digest, fork/AOF stalls)
+queue-aiops analyze backlog    # rabbitmq queue-backlog RCA (consumers, unacked, watermarks)
+queue-aiops analyze churn      # connection churn, both platforms
+queue-aiops redis bigkeys      # SCAN-budgeted big-key sample (never KEYS *)
+queue-aiops rabbitmq queues    # deepest backlog first
+```
+
+## Support scope
+
+| Platform | Protocol | Coverage |
+|----------|----------|----------|
+| **redis** (5.x–7.x wire protocol via `redis` Python client) | RESP, password optional, TLS optional | INFO (server/memory/clients/stats/persistence/keyspace), SLOWLOG, CLIENT LIST/KILL, CONFIG GET/SET, MEMORY STATS/USAGE, SCAN-budgeted big-key sampling, DBSIZE, PING |
+| **rabbitmq** (management plugin HTTP API) | HTTP(S), Basic auth | /api/overview, /api/queues (+ per-vhost, detail, purge, declare, delete), /api/connections, /api/channels, /api/consumers, /api/policies (get/set/delete), /api/nodes |
+
+**26 MCP tools** — 19 reads (incl. 4 flagship RCAs) + 7 governed writes.
+
+| Group | Tools | R/W |
+|-------|-------|:---:|
+| Overview | queue_overview | read |
+| redis reads | redis_server_info, redis_memory_stats, redis_clients, redis_slowlog, redis_config_get, redis_keyspace, redis_big_keys | read |
+| rabbitmq reads | rabbitmq_overview, list_queues, queue_detail, list_connections, list_channels, list_policies, node_health | read |
+| Flagship RCAs | redis_memory_pressure_rca, redis_latency_rca, rabbitmq_queue_backlog_rca, connection_churn_analysis | read |
+| Writes (medium) | redis_config_set, redis_kill_client, declare_queue, set_policy, delete_policy | write |
+| Writes (**high**) | purge_queue, delete_queue | write |
+
+The four RCAs are transparent heuristics that report their numbers — thresholds
+are named constants, every finding carries its evidence, never a black-box
+verdict. Big-key sampling walks at most 10,000 keys with SCAN and sizes at most
+200 with MEMORY USAGE — **never `KEYS *`** — and reports its coverage.
+
+## Governance
+
+Every MCP tool runs through the bundled `@governed_tool` harness
+(`queue_aiops.governance` — no external dependency):
+
+- **Audit** — every call lands in `~/.queue-aiops/audit.db` (relocatable via
+  `QUEUE_AIOPS_HOME`), secret-redacted.
+- **Budget** — call/time ceilings (`QUEUE_MAX_TOOL_CALLS`,
+  `QUEUE_MAX_TOOL_SECONDS`) + a runaway-loop breaker.
+- **Risk tiers & approval** — **secure by default**: with no
+  `~/.queue-aiops/rules.yaml`, high-risk writes (`purge_queue`,
+  `delete_queue`) are denied unless `QUEUE_AUDIT_APPROVED_BY` names an approver
+  (set `QUEUE_AUDIT_RATIONALE` too). `queue-aiops init` seeds a starter
+  rules.yaml with that dual-control tier; an operator-authored rules file is
+  honoured as-is.
+- **Undo** — reversible writes capture the real before-state first:
+  `redis_config_set` records the prior value from CONFIG GET;
+  `set_policy`/`delete_policy` record the prior policy; `delete_queue` records
+  the queue's definition and its undo re-declares it (the **messages are not
+  restored** — the descriptor says so). Irreversible writes (`purge_queue`,
+  `redis_kill_client`) record priorState only.
+- **Dry-run + double-confirm** — every write takes `dry_run=True` (MCP) /
+  `--dry-run` (CLI); CLI writes double-confirm and execute through the same
+  governed twins, so they land in the audit log too.
+- Credentials live **encrypted** in `~/.queue-aiops/secrets.enc` (Fernet +
+  scrypt master password; `QUEUE_AIOPS_MASTER_PASSWORD` for non-interactive
+  use). Redis passwords are optional — an auth-less lab instance is a
+  supported target.
+
+## MCP configuration
+
+```json
+{
+  "mcpServers": {
+    "queue-aiops": {
+      "command": "uvx",
+      "args": ["--from", "queue-aiops", "queue-aiops-mcp"],
+      "env": {
+        "QUEUE_AIOPS_MASTER_PASSWORD": "your-master-password"
+      }
+    }
+  }
+}
+```
+
+> **env-block caveat**: MCP clients launch the server with a *minimal*
+> environment — your shell profile is not sourced. Anything the server needs
+> (`QUEUE_AIOPS_MASTER_PASSWORD`, a relocated `QUEUE_AIOPS_HOME`,
+> `QUEUE_AUDIT_APPROVED_BY` for high-risk writes) must be set in the `env`
+> block above, not just in your terminal.
+
+Or, with the package installed: `queue-aiops mcp`.
+
+## CLI reference (short)
+
+```text
+queue-aiops init | doctor | overview | mcp
+queue-aiops secret set|list|migrate ...
+queue-aiops redis info|memory|clients|slowlog|config-get|keyspace|bigkeys
+queue-aiops redis config-set <param> <value> [--dry-run]
+queue-aiops redis kill-client --id <id> | --addr <ip:port> [--dry-run]
+queue-aiops rabbitmq overview|queues|queue|connections|channels|policies|nodes
+queue-aiops rabbitmq purge|delete-queue|declare-queue <name> [--vhost /] [--dry-run]
+queue-aiops rabbitmq set-policy|delete-policy <name> ... [--dry-run]
+queue-aiops analyze memory|latency|backlog|churn
+```
+
+## Verification status
+
+Preview / mock-only: the full test suite runs against mocked clients (no live
+broker needed), and the REST paths / INFO fields are modelled from the public
+docs of both platforms. Not yet validated against live production brokers —
+both are trivially self-hostable, so `queue-aiops doctor` against a
+local lab redis instance / rabbitmq broker (management plugin enabled) is
+the quickest live check.
+
+## Contributing
+
+缺功能提 issue/PR 欢迎留言 — missing a read you need (streams/consumer groups,
+quorum-queue specifics, shovel/federation status), another broker platform, or
+a threshold that doesn't fit your fleet? Open an issue or PR at
+[github.com/AIops-tools/Queue-AIops](https://github.com/AIops-tools/Queue-AIops)
+— platform registry entries are additive and small.
+
+## License
+
+MIT

queue_aiops-0.1.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+mcp_server/__init__.py,sha256=XVUc40BzvXjOnX5B3XGaTpcCoLnoetmU71CDvwpt2GA,42
+mcp_server/_shared.py,sha256=PDBWM3452U51poJEpk50rhbCcyLnJvjALmePVmyGRJk,4149
+mcp_server/server.py,sha256=HF7N6SOlpMWAoEMJsvMFKK9D1A24yZjYuPqcXnuB78s,1276
+mcp_server/tools/__init__.py,sha256=AZOqmTsbMg1fh8IsC9fv0NSDdkNA_ohgiyueeO5kjAo,76
+mcp_server/tools/analysis.py,sha256=V68ennFNyvvTCCmH08cjOEqS-Q0cnln0LqHo-aU0xEg,6298
+mcp_server/tools/overview.py,sha256=ARvuKrZkaB_ftHLfw4_mZik3VMvL2tBpT6ur-k04x9s,808
+mcp_server/tools/rabbit_reads.py,sha256=tYmtrTJCTQ8y2ElEBsGEs1-WmCFw6esBfhnUWorZ9Ag,3093
+mcp_server/tools/redis_reads.py,sha256=QG0xV2LGUqnXx7hRIB41LmefHPD5DaN1A4vhylXKv5w,3116
+mcp_server/tools/undo.py,sha256=bVThzb2-OkWy0axlmQH9YdxDlrFHFAKV8dG3ONoImMg,4361
+mcp_server/tools/writes.py,sha256=LNxU82ZSx4s5_rnkx2yHLJsbAGAC7gFGqadW6VBfdDk,13291
+queue_aiops/__init__.py,sha256=plKtVKs1akljMEgbKqTO1WcKtRqORDK9mmvw69CbrT0,569
+queue_aiops/config.py,sha256=vLr1kvYFD3ZCcmyhwwbBU0znLBPhQDdrQJ8hS3u5G60,5977
+queue_aiops/connection.py,sha256=H9wFAfIQZaKRGY3kuWUP8F-yb9HbMUOFpWhEY_8X-ks,11264
+queue_aiops/doctor.py,sha256=4c-WVUGhAhlYAhMRWMdL_PyE7RIXv3hO8AowPNVymxY,3599
+queue_aiops/platform.py,sha256=tM_0_hHao1bGV7oRuU0qEWagKDBZWvJhBF2jPVrrPeA,7685
+queue_aiops/secretstore.py,sha256=Bh2doYSBCwXG4uT3NDdfzTCXouFjaycr9z10Qn1Bs9Y,11920
+queue_aiops/cli/__init__.py,sha256=Qv9eFVZgh4sUGYyetNqkefMdSqkEmeS8cpFnL11kLxQ,200
+queue_aiops/cli/_common.py,sha256=eHJRVxPBigt_QyRG_5toM8e12Dnpu0zAAxNTOiYb410,2840
+queue_aiops/cli/_root.py,sha256=UcAfWr_6RWHaUrCEUURyQpEyyOiUSe5CnZdl5IDUzuU,1874
+queue_aiops/cli/analyze.py,sha256=v86QhusS7g6VizY-r-Bfs-OTYXPlazmAWBC56QfoJ84,2819
+queue_aiops/cli/doctor.py,sha256=aXv8sMEK4-RX7Vdd5ikQ-2q5VV0bXWepG82B9Fu6TMA,526
+queue_aiops/cli/init.py,sha256=kNJ0gjAO8D_QhDYWmOBH2Nk6XnoJtBi_Lg3SHvByHgM,6794
+queue_aiops/cli/overview.py,sha256=Kgimib1NKZzFBKAmgbeZvEY8QU0PrWqL6DagNwreC1Y,490
+queue_aiops/cli/rabbit_cmds.py,sha256=w9WzrneA3vDjX15qlKkQoo89blini_QZE1UJYV4L3Oc,7828
+queue_aiops/cli/redis_cmds.py,sha256=SY942IRolN2n82wVK4PcpeSH7ea2XSLx6xLYw_VmNt8,4610
+queue_aiops/cli/secret.py,sha256=gRjJedKjAoASuUFyq3ap3vvsBoUfPSVW31s4PmbaNjY,3495
+queue_aiops/cli/undo.py,sha256=GDXdu104Ip14HQ_3No-unUWPZ33WA3xzObLXxA-oJqk,1871
+queue_aiops/governance/__init__.py,sha256=IKnWVdYXngwn2aRST7RK1eLsunlE9qbARMSownQwL-o,1499
+queue_aiops/governance/audit.py,sha256=l_K8KOhRr4LtnvZgmaO4zkXjgrvm_UYCDe-hkJHYmFE,13540
+queue_aiops/governance/budget.py,sha256=XZxoQltsjVrZ_Q5f3XwootFnzzThyiCPdcNMxBJGmF8,9142
+queue_aiops/governance/decorators.py,sha256=gctPeffGdvUMFU14A_M-dHHLZHASRjHdxjIaaX14SsA,18456
+queue_aiops/governance/paths.py,sha256=W68k2KZN8PBAxm819BNkDSIe9IomIL7D1q7ckN_KL3Y,709
+queue_aiops/governance/patterns.py,sha256=vzdrn1--i5S8Q6DELf2xoJYLxKK5S_hpxSSpZ7par-M,15553
+queue_aiops/governance/policy.py,sha256=mlzRK6s8LQYzNIQYrcqXe_L3L7qp0RL4WySKSbxJTc4,17215
+queue_aiops/governance/sanitize.py,sha256=q8b_mbTEiojR3PmSS8JvHj5NnjOqz8SpXQ7XRBeG0KA,1728
+queue_aiops/governance/undo.py,sha256=iOx6BCLimy3sQ5sMgpd4NKeTqogx6hBBB642QoIVKCU,7770
+queue_aiops/ops/__init__.py,sha256=mr0nG_uSUHU8e6-t-vDfvXtoMPOyWmd844T2nKwibfw,76
+queue_aiops/ops/_util.py,sha256=NJ28wq3s28O8LuE0gRikNep0J9VCQKnZjRSXxRK3T8E,1775
+queue_aiops/ops/analysis.py,sha256=2CVulWsQl5hjvE6QhCCYPK12t-AtW2wiozKuxCuoX9M,26556
+queue_aiops/ops/overview.py,sha256=xCEQyu_n7vOm8cDrL67XMmfFaAWWHYfwEAFmoGr19Bg,3122
+queue_aiops/ops/rabbit_reads.py,sha256=O1B9MAHy38CzMbbd2GaDbRRIFdnY_kmyrPftuMW36cs,9006
+queue_aiops/ops/redis_reads.py,sha256=m8bqfjXJk1Qe88f1wyCegg6xcTXO99cEz-SyTvGStzM,9386
+queue_aiops/ops/writes.py,sha256=rvI1TcKwBxoTsdmReRYyJQZyiC7rfPGrYiVXpoeM8h4,10430
+queue_aiops-0.1.0.dist-info/METADATA,sha256=FfzyhTjTok7A4vE2H7fAcE99NTuk4oyXiZsY-GqAIY8,8058
+queue_aiops-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+queue_aiops-0.1.0.dist-info/entry_points.txt,sha256=wa1r7KIvAQeFrCYHJYspzoRZubLLEYFDWmI-fUS_zGA,93
+queue_aiops-0.1.0.dist-info/licenses/LICENSE,sha256=-aN-YMNjW-2HFH71T7ohVfCJf9XeNX0MSVcPFpsgs_8,1083
+queue_aiops-0.1.0.dist-info/RECORD,,

queue_aiops-0.1.0.dist-info/WHEEL

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

queue_aiops-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+queue-aiops = queue_aiops.cli:app
+queue-aiops-mcp = mcp_server.server:main

queue_aiops-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wei <zhouwei008@gmail.com>
+
+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.