queue-aiops 0.1.1__tar.gz → 0.2.1__tar.gz

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queue-aiops
-Version: 0.1.1
+Version: 0.2.1
 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
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
 
 <!-- mcp-name: io.github.AIops-tools/queue-aiops -->
 
-# Queue AIops (preview)
+# Queue AIops
 
 **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
@@ -33,9 +33,10 @@ by the built-in governance harness.
 > 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.
+> **Verification**: behaviour is covered by a mock-based test suite; not yet validated
+> against live 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, and [docs/VERIFICATION.md](docs/VERIFICATION.md) is the checklist.
 
 ## Quick start
 
@@ -58,6 +59,46 @@ queue-aiops redis bigkeys      # SCAN-budgeted big-key sample (never KEYS *)
 queue-aiops rabbitmq queues    # deepest backlog first
 ```
 
+## Security: read-only mode
+
+This tool is meant to be handed to an AI agent, so its safety story is enforced
+by the server rather than requested in a prompt:
+
+```bash
+export QUEUE_READ_ONLY=1
+```
+
+With that set, the **8 write tools are never registered**. An MCP client
+lists **20 tools instead of 28** — the writes are not hidden, not
+gated behind a flag, and not merely refused when called. They are absent from
+the session. A model cannot invoke a tool it was never offered, and cannot be
+argued into one.
+
+That distinction is the whole point. A tool that exists but refuses still invites
+retry loops and "I'll describe the call instead" behaviour from smaller models,
+and it leaves a reviewer trusting a promise. An absent tool is a fact you can
+check: connect, list the tools, and see that the writes are not there.
+
+Enforcement is two layers deep, so the switch cannot be sidestepped by changing
+entry point:
+
+| Layer | What it does | Covers |
+|---|---|---|
+| `@governed_tool` harness | refuses every non-read operation outright | MCP, CLI, and in-process callers |
+| MCP registration | write tools are removed from `list_tools()` | anything speaking MCP |
+
+Read operations are unaffected, and every call is still audited to
+`~/.queue-aiops/audit.db`.
+
+> The read/write split is derived from each tool's declared `risk_level`, and a
+> test asserts that this never disagrees with the `[READ]`/`[WRITE]` tag in the
+> tool's own documentation — so a write can't quietly present itself as a read.
+
+Running a smaller / local model? See
+[agent-guardrails.md](skills/queue-aiops/references/agent-guardrails.md) — it lists
+the guardrails this tool now enforces for you (so you don't spend prompt budget
+restating them) and gives a ready-made system prompt for what's left.
+
 ## Support scope
 
 | Platform | Protocol | Coverage |
@@ -65,7 +106,7 @@ queue-aiops rabbitmq queues    # deepest backlog first
 | **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.
+**28 MCP tools** — 20 reads (incl. 4 flagship RCAs) + 8 governed writes.
 
 | Group | Tools | R/W |
 |-------|-------|:---:|
@@ -75,6 +116,7 @@ queue-aiops rabbitmq queues    # deepest backlog first
 | 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 |
+| Undo | undo_list, undo_apply | read / write |
 
 The four RCAs are transparent heuristics that report their numbers — thresholds
 are named constants, every finding carries its evidence, never a black-box
@@ -150,12 +192,19 @@ 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.
+**Live-verified against Redis 7.4.9 (2026-07-19); RabbitMQ still mock-only.**
+Connectivity, every Redis read (cross-checked against `redis-cli` ground truth), all
+four analyses, and the full governance loop (real `redis_config_set` → audit row →
+undo restoring the prior value) were exercised against a real server. That run found
+and fixed a real defect: integer quantities — key counts, client counts, byte totals —
+were rendered as floats (`202.0` keys), which equality assertions cannot catch.
+
+The **entire RabbitMQ command group** remains unverified against a live broker, as do
+Redis cluster/sentinel topologies and AUTH/TLS connections.
+
+[docs/VERIFICATION.md](docs/VERIFICATION.md) records exactly what was checked and what
+is still open. `queue-aiops doctor` is the fastest live check.
+
 
 ## Contributing
 

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/README.md

@@ -1,6 +1,6 @@
 <!-- mcp-name: io.github.AIops-tools/queue-aiops -->
 
-# Queue AIops (preview)
+# Queue AIops
 
 **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
@@ -16,9 +16,10 @@ by the built-in governance harness.
 > 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.
+> **Verification**: behaviour is covered by a mock-based test suite; not yet validated
+> against live 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, and [docs/VERIFICATION.md](docs/VERIFICATION.md) is the checklist.
 
 ## Quick start
 
@@ -41,6 +42,46 @@ queue-aiops redis bigkeys      # SCAN-budgeted big-key sample (never KEYS *)
 queue-aiops rabbitmq queues    # deepest backlog first
 ```
 
+## Security: read-only mode
+
+This tool is meant to be handed to an AI agent, so its safety story is enforced
+by the server rather than requested in a prompt:
+
+```bash
+export QUEUE_READ_ONLY=1
+```
+
+With that set, the **8 write tools are never registered**. An MCP client
+lists **20 tools instead of 28** — the writes are not hidden, not
+gated behind a flag, and not merely refused when called. They are absent from
+the session. A model cannot invoke a tool it was never offered, and cannot be
+argued into one.
+
+That distinction is the whole point. A tool that exists but refuses still invites
+retry loops and "I'll describe the call instead" behaviour from smaller models,
+and it leaves a reviewer trusting a promise. An absent tool is a fact you can
+check: connect, list the tools, and see that the writes are not there.
+
+Enforcement is two layers deep, so the switch cannot be sidestepped by changing
+entry point:
+
+| Layer | What it does | Covers |
+|---|---|---|
+| `@governed_tool` harness | refuses every non-read operation outright | MCP, CLI, and in-process callers |
+| MCP registration | write tools are removed from `list_tools()` | anything speaking MCP |
+
+Read operations are unaffected, and every call is still audited to
+`~/.queue-aiops/audit.db`.
+
+> The read/write split is derived from each tool's declared `risk_level`, and a
+> test asserts that this never disagrees with the `[READ]`/`[WRITE]` tag in the
+> tool's own documentation — so a write can't quietly present itself as a read.
+
+Running a smaller / local model? See
+[agent-guardrails.md](skills/queue-aiops/references/agent-guardrails.md) — it lists
+the guardrails this tool now enforces for you (so you don't spend prompt budget
+restating them) and gives a ready-made system prompt for what's left.
+
 ## Support scope
 
 | Platform | Protocol | Coverage |
@@ -48,7 +89,7 @@ queue-aiops rabbitmq queues    # deepest backlog first
 | **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.
+**28 MCP tools** — 20 reads (incl. 4 flagship RCAs) + 8 governed writes.
 
 | Group | Tools | R/W |
 |-------|-------|:---:|
@@ -58,6 +99,7 @@ queue-aiops rabbitmq queues    # deepest backlog first
 | 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 |
+| Undo | undo_list, undo_apply | read / write |
 
 The four RCAs are transparent heuristics that report their numbers — thresholds
 are named constants, every finding carries its evidence, never a black-box
@@ -133,12 +175,19 @@ 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.
+**Live-verified against Redis 7.4.9 (2026-07-19); RabbitMQ still mock-only.**
+Connectivity, every Redis read (cross-checked against `redis-cli` ground truth), all
+four analyses, and the full governance loop (real `redis_config_set` → audit row →
+undo restoring the prior value) were exercised against a real server. That run found
+and fixed a real defect: integer quantities — key counts, client counts, byte totals —
+were rendered as floats (`202.0` keys), which equality assertions cannot catch.
+
+The **entire RabbitMQ command group** remains unverified against a live broker, as do
+Redis cluster/sentinel topologies and AUTH/TLS connections.
+
+[docs/VERIFICATION.md](docs/VERIFICATION.md) records exactly what was checked and what
+is still open. `queue-aiops doctor` is the fastest live check.
+
 
 ## Contributing
 

queue_aiops-0.2.1/RELEASE_NOTES.md

@@ -0,0 +1,26 @@
+# Release notes — queue-aiops 0.2.1
+
+Previous release: 0.2.0.
+
+## Fixed: integer quantities were rendered as floats
+
+Key counts, client counts and byte totals were routed through the float coercion
+helper, so a live server reported `202.0` keys and `1.0` connected clients. The
+values were arithmetically right but semantically wrong — a count cannot be
+fractional, and a reader should not have to wonder whether `.0` means the number was
+rounded.
+
+These now use a new `as_int()` helper and come back as integers. Genuinely fractional
+values (`hitRatePct`, `usedPctOfMax`, `opsPerSec`, `expiresPct`) are unchanged. Note
+that equality assertions cannot catch this class of bug (`202 == 202.0`), so the
+regression test asserts the *type*.
+
+If you parse these fields, the JSON shape changes from `202.0` to `202`.
+
+## Live-verified
+
+This release was exercised end-to-end against a real **Redis 7.4.9** server: every
+Redis read cross-checked against `redis-cli` ground truth, all four analyses, and the
+full governance loop (real `redis_config_set` → audit row → `undo_apply` restoring the
+prior value). See [docs/VERIFICATION.md](docs/VERIFICATION.md) — **RabbitMQ remains
+mock-only** and is now the largest gap in this repo.

queue_aiops-0.2.1/docs/VERIFICATION.md

@@ -0,0 +1,34 @@
+# Live verification status
+
+This document records what has and has not been validated against real Redis /
+RabbitMQ servers, so the maturity claim is auditable rather than a vibe.
+
+## Already live-verified ✅ — Redis 7.4.9, 2026-07-19
+
+Exercised end-to-end against a real **Redis 7.4.9** server (Docker) seeded with
+202 keys and a list-backed job queue:
+
+- `doctor` against a live server: PING OK, no-AUTH lab path reported clearly.
+- Every Redis read cross-checked against `redis-cli` ground truth:
+  `overview`, `redis info/memory/clients/slowlog/keyspace/bigkeys`
+  (key count matched `DBSIZE` exactly).
+- All four analyses ran clean: `analyze memory/latency/backlog/churn`.
+- Governance loop end-to-end: `redis_config_set` really changed
+  `maxmemory-policy`, captured `noeviction` as `priorState`, wrote an audit row
+  with approver, and `undo_apply` restored the prior value on the live server.
+
+**A real defect was found and fixed by this run**: integer quantities were
+rendered as floats — `202.0` keys, `1.0` connected clients, float byte counts —
+because they were routed through `num()`. Values were arithmetically right but
+semantically wrong, and equality assertions could not catch it
+(`202 == 202.0`). Fixed with `as_int()` across the Redis and RabbitMQ reads,
+plus a regression test that asserts the *type*, keeping genuine ratios
+(`hitRatePct`, `usedPctOfMax`, `opsPerSec`) as floats.
+
+## Not yet live-verified ⚠️
+
+- **RabbitMQ** — the entire `rabbitmq` command group and its management-API
+  shapes are unit-tested only. This is now the largest gap in this repo.
+- Redis **cluster / sentinel** topologies (only standalone was exercised).
+- AUTH-enabled Redis and TLS connections.
+- `kill-client` against a real blocked client.

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/mcp_server/_shared.py

@@ -75,7 +75,7 @@ def tool_errors(shape: str = "dict") -> Callable:
 mcp = FastMCP(
     "queue-aiops",
     instructions=(
-        "Queue/cache broker operations (preview) over redis and rabbitmq: for a "
+        "Queue/cache broker operations over redis and rabbitmq: for a "
         "redis target — server/memory/keyspace reads, clients, slowlog, config, "
         "and a SCAN-budgeted big-key sample (never KEYS *); for a rabbitmq "
         "target — management-API overview, queues, connections, channels, "

queue_aiops-0.2.1/mcp_server/server.py

@@ -0,0 +1,76 @@
+"""MCP server wrapping queue-aiops operations (stdio transport).
+
+Thin adapter layer: each ``@mcp.tool()`` function (in ``mcp_server/tools/``)
+delegates to the ``queue_aiops`` ops package and is wrapped with the
+queue-aiops ``@governed_tool`` harness (audit / budget / undo / risk-tier).
+
+Standalone, self-governed broker operations over redis and rabbitmq:
+redis server/memory/clients/slowlog/config/keyspace/big-key reads, rabbitmq
+overview/queues/connections/channels/policies/node reads, four flagship
+analyses, and governed writes (redis config set + client kill; rabbitmq queue
+purge/delete/declare and policy set/delete).
+
+Source: https://github.com/AIops-tools/Queue-AIops
+License: MIT
+"""
+
+import logging
+
+from mcp_server._shared import _safe_error, mcp, tool_errors
+
+# Importing the tool modules registers every @mcp.tool() onto the shared
+# `mcp` instance. Order does not matter; each module is self-contained.
+from mcp_server.tools import (  # noqa: F401 — side effects
+    analysis,
+    overview,
+    rabbit_reads,
+    redis_reads,
+    undo,
+    writes,
+)
+from queue_aiops.governance import READ_ONLY_ENV, is_read_only
+
+__all__ = ["mcp", "main", "_safe_error", "tool_errors", "apply_read_only"]
+
+logger = logging.getLogger(__name__)
+
+
+def apply_read_only() -> list[str]:
+    """Unregister every write tool when read-only mode is on.
+
+    The ``@governed_tool`` harness already refuses writes in this mode, so this
+    is a second layer — and the one that matters for smaller local models:
+    a tool absent from ``list_tools()`` cannot be hallucinated into a call,
+    whereas a tool that exists but refuses invites retry loops. It also gives a
+    compliance reviewer something checkable — the write tools are simply not
+    exposed.
+
+    ``risk_level == "low"`` is the read/write discriminator; a smoke test
+    asserts it stays in agreement with each tool's ``[READ]``/``[WRITE]``
+    docstring tag so the two can never drift apart silently.
+
+    Returns the names that were removed (empty when not in read-only mode).
+    """
+    if not is_read_only():
+        return []
+    registry = mcp._tool_manager._tools
+    dropped = [
+        name
+        for name, tool in registry.items()
+        if getattr(getattr(tool, "fn", None), "_risk_level", "low") != "low"
+    ]
+    for name in dropped:
+        del registry[name]
+    if dropped:
+        logger.info(
+            "%s is set — read-only mode: %d write tool(s) not exposed",
+            READ_ONLY_ENV, len(dropped),
+        )
+    return dropped
+
+
+def main() -> None:
+    """Run the MCP server over stdio."""
+    logging.basicConfig(level=logging.INFO)
+    apply_read_only()
+    mcp.run(transport="stdio")

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/mcp_server/tools/rabbit_reads.py

@@ -28,6 +28,10 @@ def list_queues(vhost: Optional[str] = None, target: Optional[str] = None) -> di
     Args:
         vhost: Restrict to one vhost (the default vhost is '/'); omit for all.
         target: rabbitmq target name from config; omit for the default.
+
+    Returns an envelope: {"queues": [...], "returned": N, "limit": L,
+    "truncated": bool}. When "truncated" is true there is more than was
+    returned — do not treat this as the complete set.
     """
     return ops.list_queues(_get_connection(target), vhost)
 
@@ -54,6 +58,10 @@ def list_connections(target: Optional[str] = None) -> dict:
 
     Args:
         target: rabbitmq target name from config; omit for the default.
+
+    Returns an envelope: {"connections": [...], "returned": N, "limit": L,
+    "truncated": bool}. When "truncated" is true there is more than was
+    returned — do not treat this as the complete set.
     """
     return ops.list_connections(_get_connection(target))
 
@@ -66,6 +74,10 @@ def list_channels(target: Optional[str] = None) -> dict:
 
     Args:
         target: rabbitmq target name from config; omit for the default.
+
+    Returns an envelope: {"channels": [...], "returned": N, "limit": L,
+    "truncated": bool}. When "truncated" is true there is more than was
+    returned — do not treat this as the complete set.
     """
     return ops.list_channels(_get_connection(target))
 
@@ -79,6 +91,10 @@ def list_policies(vhost: Optional[str] = None, target: Optional[str] = None) ->
     Args:
         vhost: Restrict to one vhost (the default vhost is '/'); omit for all.
         target: rabbitmq target name from config; omit for the default.
+
+    Returns an envelope: {"policies": [...], "returned": N, "limit": L,
+    "truncated": bool}. When "truncated" is true there is more than was
+    returned — do not treat this as the complete set.
     """
     return ops.list_policies(_get_connection(target), vhost)
 

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/mcp_server/tools/redis_reads.py

@@ -39,6 +39,10 @@ def redis_clients(target: Optional[str] = None) -> dict:
 
     Args:
         target: redis target name from config; omit for the default.
+
+    Returns an envelope: {"clients": [...], "returned": N, "limit": L,
+    "truncated": bool}. When "truncated" is true there is more than was
+    returned — do not treat this as the complete set.
     """
     return ops.list_clients(_get_connection(target))
 
@@ -52,6 +56,10 @@ def redis_slowlog(count: int = 128, target: Optional[str] = None) -> dict:
     Args:
         count: Max entries to pull (capped at 128).
         target: redis target name from config; omit for the default.
+
+    Returns an envelope: {"entries": [...], "returned": N, "limit": L,
+    "truncated": bool}. When "truncated" is true there is more than was
+    returned — do not treat this as the complete set.
     """
     return ops.slowlog(_get_connection(target), count)
 
@@ -94,5 +102,9 @@ def redis_big_keys(top: int = 20, target: Optional[str] = None) -> dict:
     Args:
         top: How many key rows to return, largest first (default 20).
         target: redis target name from config; omit for the default.
+
+    Returns an envelope: {"topKeys": [...], "returned": N, "limit": L,
+    "truncated": bool}. When "truncated" is true there is more than was
+    returned — do not treat this as the complete set.
     """
     return ops.big_key_sample(_get_connection(target), top)

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/mcp_server/tools/undo.py

@@ -36,13 +36,24 @@ def undo_list(limit: int = 50, target: Optional[str] = None) -> dict:
     Each entry names the original tool, the inverse tool that ``undo_apply``
     would run, and a human note. Use the ``undoId`` with ``undo_apply``.
 
+    Returns {"undos": [...], "returned": N, "limit": L, "truncated": bool}.
+    ``truncated`` is *measured* (one extra row is fetched), not guessed from a
+    length coincidence: when it is true there are MORE tokens than shown, so
+    re-run with a higher ``limit`` rather than reporting the list as complete.
+
     Args:
-        limit: Max rows to return (default 50).
+        limit: Max rows to return (default 50, capped at 500).
         target: Unused (undo state is host-local); accepted for CLI uniformity.
     """
-    rows = get_undo_store().list(status="recorded", limit=max(1, min(limit, 500)))
+    requested = max(1, min(limit, 500))
+    raw = get_undo_store().list(status="recorded", limit=requested + 1)
+    truncated = len(raw) > requested
+    rows = raw[:requested]
     return {
         "count": len(rows),
+        "returned": len(rows),
+        "limit": requested,
+        "truncated": truncated,
         "undos": [
             {
                 "undoId": r["undo_id"],

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "queue-aiops"
-version = "0.1.1"
+version = "0.2.1"
 description = "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)"
 readme = "README.md"
 license = "MIT"

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/queue_aiops/cli/rabbit_cmds.py

@@ -51,7 +51,13 @@ def rabbit_queues(
     from queue_aiops.ops import rabbit_reads as ops
 
     conn, _ = get_connection(target)
-    console.print_json(json.dumps(ops.list_queues(conn, vhost)))
+    result = ops.list_queues(conn, vhost)
+    console.print_json(json.dumps(result))
+    if result.get("truncated"):
+        console.print(
+            f"[yellow]… truncated at {result.get('limit')} rows — "
+            f"re-run with a higher limit to see the rest.[/yellow]"
+        )
 
 
 @rabbitmq_app.command("queue")
@@ -75,7 +81,13 @@ def rabbit_connections(target: TargetOption = None) -> None:
     from queue_aiops.ops import rabbit_reads as ops
 
     conn, _ = get_connection(target)
-    console.print_json(json.dumps(ops.list_connections(conn)))
+    result = ops.list_connections(conn)
+    console.print_json(json.dumps(result))
+    if result.get("truncated"):
+        console.print(
+            f"[yellow]… truncated at {result.get('limit')} rows — "
+            f"re-run with a higher limit to see the rest.[/yellow]"
+        )
 
 
 @rabbitmq_app.command("channels")
@@ -85,7 +97,13 @@ def rabbit_channels(target: TargetOption = None) -> None:
     from queue_aiops.ops import rabbit_reads as ops
 
     conn, _ = get_connection(target)
-    console.print_json(json.dumps(ops.list_channels(conn)))
+    result = ops.list_channels(conn)
+    console.print_json(json.dumps(result))
+    if result.get("truncated"):
+        console.print(
+            f"[yellow]… truncated at {result.get('limit')} rows — "
+            f"re-run with a higher limit to see the rest.[/yellow]"
+        )
 
 
 @rabbitmq_app.command("policies")
@@ -100,7 +118,13 @@ def rabbit_policies(
     from queue_aiops.ops import rabbit_reads as ops
 
     conn, _ = get_connection(target)
-    console.print_json(json.dumps(ops.list_policies(conn, vhost)))
+    result = ops.list_policies(conn, vhost)
+    console.print_json(json.dumps(result))
+    if result.get("truncated"):
+        console.print(
+            f"[yellow]… truncated at {result.get('limit')} rows — "
+            f"re-run with a higher limit to see the rest.[/yellow]"
+        )
 
 
 @rabbitmq_app.command("nodes")

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/queue_aiops/cli/redis_cmds.py

@@ -52,7 +52,13 @@ def redis_clients(target: TargetOption = None) -> None:
     from queue_aiops.ops import redis_reads as ops
 
     conn, _ = get_connection(target)
-    console.print_json(json.dumps(ops.list_clients(conn)))
+    result = ops.list_clients(conn)
+    console.print_json(json.dumps(result))
+    if result.get("truncated"):
+        console.print(
+            f"[yellow]… truncated at {result.get('limit')} rows — "
+            f"only the busiest clients are shown.[/yellow]"
+        )
 
 
 @redis_app.command("slowlog")
@@ -65,7 +71,13 @@ def redis_slowlog(
     from queue_aiops.ops import redis_reads as ops
 
     conn, _ = get_connection(target)
-    console.print_json(json.dumps(ops.slowlog(conn, count)))
+    result = ops.slowlog(conn, count)
+    console.print_json(json.dumps(result))
+    if result.get("truncated"):
+        console.print(
+            f"[yellow]… truncated at {result.get('limit')} rows — "
+            f"re-run with a higher --count to see the rest.[/yellow]"
+        )
 
 
 @redis_app.command("config-get")

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/queue_aiops/governance/__init__.py

@@ -18,12 +18,16 @@ from queue_aiops.governance.budget import BudgetExceeded, BudgetTracker, get_bud
 from queue_aiops.governance.decorators import PolicyDenied, governed_tool
 from queue_aiops.governance.patterns import Pattern, PatternMatch, get_pattern_engine
 from queue_aiops.governance.policy import TierDecision, get_policy_engine
-from queue_aiops.governance.sanitize import sanitize
+from queue_aiops.governance.readonly import READ_ONLY_ENV, is_read_only
+from queue_aiops.governance.sanitize import opt_str, sanitize
 from queue_aiops.governance.undo import UndoStore, get_undo_store
 
 __all__ = [
     "governed_tool",
     "sanitize",
+    "opt_str",
+    "is_read_only",
+    "READ_ONLY_ENV",
     "PolicyDenied",
     "get_engine",
     "AuditEngine",

{queue_aiops-0.1.1 → queue_aiops-0.2.1}/queue_aiops/governance/decorators.py

@@ -36,6 +36,7 @@ from queue_aiops.governance.audit import detect_agent, get_engine
 from queue_aiops.governance.budget import BudgetExceeded, get_budget
 from queue_aiops.governance.patterns import PatternMatch, get_pattern_engine
 from queue_aiops.governance.policy import PolicyResult, get_policy_engine
+from queue_aiops.governance.readonly import is_read_only, read_only_denial
 from queue_aiops.governance.sanitize import sanitize
 
 _log = logging.getLogger("queue-aiops.decorators")
@@ -233,6 +234,17 @@ def _pre_check(state: _CallState) -> None:
     never block the call (fail-open by design — a broken pattern file must
     not take down every MCP tool).
     """
+    # Read-only mode is a hard switch, checked before policy so that no write
+    # reaches an API regardless of entry point (MCP, CLI, or in-process) and
+    # regardless of what rules.yaml says. risk_level 'low' == a read.
+    if state.risk_level != "low" and is_read_only():
+        reason = read_only_denial(state.tool_name)
+        denial = PolicyResult(allowed=False, rule="read_only", reason=reason)
+        state.policy_result = denial
+        state.status = "denied"
+        state.result = {"error": reason, "rule": denial.rule}
+        raise PolicyDenied(denial)
+
     state.policy_result = state.policy.check_allowed(
         state.tool_name,
         env=state.env,