What makes minio-aiops notable?

1.3K downloads. Trust evidence available

How should minio-aiops be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

minio-aiops

Use this skill whenever the user needs to operate or diagnose MinIO object storage — explain why the cluster is filling up or refusing writes (capacity_rca), find publicly exposed buckets and hygiene gaps (bucket_exposure_audit), find storage that lifecycle/ILM should be reclaiming but isn't, including noncurrent versions and incomplete multipart uploads (lifecycle_gap_analysis), check heal backlog and erasure-set write-quorum risk (healing_health), read service health / cluster status / per-bucket config (policy, versioning, lifecycle, encryption, quota, tags) — plus governed writes (set or delete bucket policy, enable/suspend versioning, set or delete lifecycle rules, set bucket quota, purge incomplete uploads, delete an empty bucket). Always use this skill for "minio health", "why is my object storage full", "which bucket is biggest", "is any bucket public / anonymous access", "versioning / noncurrent versions piling up", "incomplete multipart uploads", "lifecycle / ILM rules", "bucket quota", "erasure set / drive failure tolerance", "healing backlog", or "delete a bucket safely" when the context is a MinIO deployment. Do NOT use when the target is not MinIO — for Ceph/RGW use ceph-aiops; for TrueNAS storage use truenas-aiops; for a hypervisor, backup product, container cluster, or network device route to the appropriate other AIops-tools skill (negative routing hint only). Common MinIO ops with a built-in governance harness (audit, policy, token budget, undo, risk-tiers).

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.3k

Updated

Oct 10, 2026

Version

0.12.3

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.3K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.3K downloadsadoption · observed Oct 10, 2026
Latest release: 0.12.3release · observed Sep 15, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s171xgnmqse0nqvgqvqnaq5f9183kyre:minio-aiops

Install using `clawhub skill install s171xgnmqse0nqvgqvqnaq5f9183kyre:minio-aiops` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/zw008/minio-aiops before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-zw008-minio-aiops/snapshot"

Documentation

CLAWHUB

149,665 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: minio-aiops
slug: minio-aiops
displayName: "MinIO AIops"
summary: "Governed MinIO ops: capacity RCA, exposure audit, ILM, WORM retention, IAM, healing, 48 tools."
license: MIT
homepage: https://github.com/AIops-tools/MinIO-AIops
tags: [aiops, mcp, governance, minio]
description: >
  Use this skill whenever the user needs to operate or diagnose MinIO object storage — explain why the cluster is filling up or refusing writes (capacity_rca), find publicly exposed buckets and hygiene gaps (bucket_exposure_audit), find storage that lifecycle/ILM should be reclaiming but isn't, including noncurrent versions and incomplete multipart uploads (lifecycle_gap_analysis), check heal backlog and erasure-set write-quorum risk (healing_health), read service health / cluster status / per-bucket config (policy, versioning, lifecycle, encryption, quota, tags) — plus governed writes (set or delete bucket policy, enable/suspend versioning, set or delete lifecycle rules, set bucket quota, purge incomplete uploads, delete an empty bucket).
  Always use this skill for "minio health", "why is my object storage full", "which bucket is biggest", "is any bucket public / anonymous access", "versioning / noncurrent versions piling up", "incomplete multipart uploads", "lifecycle / ILM rules", "bucket quota", "erasure set / drive failure tolerance", "healing backlog", or "delete a bucket safely" when the context is a MinIO deployment.
  Do NOT use when the target is not MinIO — for Ceph/RGW use ceph-aiops; for TrueNAS storage use truenas-aiops; for a hypervisor, backup product, container cluster, or network device route to the appropriate other AIops-tools skill (negative routing hint only).
  Common MinIO ops with a built-in governance harness (audit, policy, token budget, undo, risk-tiers).
installer:
  kind: uv
  package: minio-aiops
argument-hint: "[minio question or describe your object-storage task]"
allowed-tools:
  - Bash
metadata: {"openclaw":{"requires":{"anyBins":["minio-aiops","uvx"]},"optional":{"env":["MINIO_AIOPS_CONFIG","MINIO_AIOPS_MASTER_PASSWORD"]},"homepage":"https://github.com/AIops-tools/MinIO-AIops","emoji":"🪣","os":["macos","linux"]}}
compatibility: >
  Standalone, self-governed MinIO operations. The governance harness (audit, policy, token/runaway budget, undo, risk-tiers) is bundled in the package — no external skill-family dependency. Works against any reasonably current MinIO server (single-node or distributed/erasure-coded); admin features (quota, server info) need admin-capable keys.
  All write operations are audited to a local SQLite DB under ~/.minio-aiops/ (relocatable via MINIO_AIOPS_HOME).
  Connection: the S3 API endpoint (host:port, default 9000; SigV4 via the official SDK), plus the unauthenticated health endpoints (/minio/health/live|ready|cluster) and the cluster metrics endpoint (/minio/v2/metrics/cluster — public mode or the default bearer-token mode; the token is derived from the stored credentials, no extra secret). The acc

_meta.json

{
  "ownerId": "kn7b067awq2s97bn3d7p5qfhw5827pxc",
  "slug": "minio-aiops",
  "version": "0.12.3",
  "publishedAt": 1789452271684
}

references/agent-guardrails.md

# Agent guardrails — running minio-aiops with a smaller / local model

If you drive these tools with a local model (Llama, Qwen, Mistral … via Goose,
Ollama, LM Studio, or any OpenAI-compatible runtime), you will get noticeably
better results with a short system prompt. This page gives you one, and — more
importantly — tells you which guardrails you **no longer need to write**, because
the tool now enforces them itself.

The distinction matters. A guardrail in a prompt is a request. A guardrail in the
harness is a guarantee. Anything below that we could move into the harness, we did.

## Authorization is not this tool's job — decide it where it belongs

Whether a write should happen is your decision, or the account's. The tool does
not gate it — there is no read-only switch and no approval prompt to configure.
The two right places to control read vs write:

- **The access key you connect with.** Give it a read-only IAM policy. A write
then fails at the server, which is the only place the permission actually
lives — no skill-side flag can be argued around by a model, but a revoked
permission cannot be.
- **Your agent's system prompt.** If you want an observe-only session, tell the
model not to call the write tools (they are clearly tagged `[WRITE]`).

What the tool *does* guarantee is that you can always see what happened:

## What the tool enforces — do not waste prompt budget on these

| You might be tempted to prompt | Why you don't need to |
|---|---|
| "Don't invent a value when a field is missing" | A field the API did not return comes back as `null`, never as `""` — a bucket with no `createdAt`, an object with no `lastModified`/`versionId`, an upload with no `initiated` time. Absent and empty are distinguishable in the payload. |
| "Tell me if the object list was cut off" | Every bounded listing returns `{"objects": [...], "returned": N, "limit": L, "truncated": true/false}` (and the same shape with `buckets` / `uploads`). Truncation is measured — `object_ls` fetches one row past the limit, the bucket/upload/usage listings measure against the full set — never guessed from the count equalling the limit. |
| "Tell me which exposed bucket to fix first" | `bucket_exposure_audit` returns findings sorted riskiest-first with an explicit `riskScore` and `riskLevel`; `capacity_rca`, `healing_health`, and `lifecycle_gap_analysis` each attach a `severity` plus `cause` and `suggestedAction` to every finding. The priority is in the payload, not implied by list position. |
| "Confirm before anything destructive" | Destructive operations require a `--dry-run`-able preview + double confirmation at the CLI. `bucket_delete` additionally refuses unless the bucket is verifiably empty (including noncurrent versions and delete markers). |
| "Log what you did" | Every call is audited to `~/.minio-aiops/audit.db` regardless of what the model says it did. Reversible writes record their prior state (`priorState`) so `undo_list` / `undo_apply` can roll them b

references/capabilities.md

# minio-aiops capabilities

> 48 MCP tools (28 read, 18 write, 2 undo) over four access paths:
> the **S3 API** (official SDK, SigV4), the **admin API**, the unauthenticated
> **health endpoints**, and the **cluster metrics endpoint**.

## Health (read)

| Tool | Surface | Returns |
|------|---------|---------|
| `health_live` | `GET /minio/health/live` | node liveness (reachable/healthy/status code) |
| `health_ready` | `GET /minio/health/ready` | node readiness |
| `health_cluster` | `GET /minio/health/cluster` | write-quorum health (503 = degraded) + live/ready + overall verdict |
| `cluster_status` | metrics endpoint | nodes/drives online+offline, raw/usable capacity, buckets, objects |
| `fleet_overview` | composite | health + capacity headline + exposure headline in one call |

## Flagship analyses (read)

| Tool | Surface | Returns |
|------|---------|---------|
| `capacity_rca` | metrics endpoint | findings with **cause + suggestedAction**: CLUSTER_FULL / CLUSTER_NEARFULL / DRIVES_OFFLINE / NODES_OFFLINE / DRIVE_HOTSPOT / DRIVE_IMBALANCE; per-drive usage table |
| `usage_by_bucket` | metrics endpoint | envelope `{buckets, returned, limit, truncated}` — per-bucket bytes + objects, biggest first |
| `healing_health` | metrics endpoint | per-erasure-set online drives / write quorum / **failureToleranceRemaining**, healing drives, heal backlog + errors; findings WRITE_QUORUM_LOST / _AT_EDGE / LOW_FAILURE_TOLERANCE / HEALING_IN_PROGRESS / HEAL_ERRORS |
| `drive_status` | metrics endpoint | per-drive rows (server, drive, used ratio), fullest first |
| `node_status` | metrics endpoint | nodes online/offline + per-node drive counts |
| `bucket_exposure_audit` | S3 API per bucket | reports `bucketsAudited`/`bucketsTotal`/`truncated`; **ranked** findings: PUBLIC_WRITE_POLICY / PUBLIC_READ_POLICY / NO_DEFAULT_ENCRYPTION / VERSIONING_OFF / NO_LIFECYCLE with riskScore + riskLevel |
| `lifecycle_gap_analysis` | S3 API + metrics | reports `bucketsAnalyzed`/`bucketsTotal`/`truncated`; gaps: NONCURRENT_VERSIONS_UNBOUNDED (+reclaimable estimate) / INCOMPLETE_UPLOADS_NO_ABORT_RULE (+counts, ages) / NO_LIFECYCLE_ON_LARGE_BUCKET |
| `diagnose_retention_gaps` | S3 API per bucket | envelope `{findings, returned, limit, truncated}` + `bucketErrors`; worst-first with `rank`: LIFECYCLE_CANNOT_EXPIRE_UNDER_RETENTION (both day counts + shortfall) / LOCK_ENABLED_NO_DEFAULT_RETENTION / LOCK_WITHOUT_ACTIVE_VERSIONING / COMPLIANCE_DEFAULT_LONG / GOVERNANCE_DEFAULT_BYPASSABLE |

## Buckets (read)

| Tool | Surface | Returns |
|------|---------|---------|
| `bucket_ls` | `ListBuckets` | envelope `{buckets, returned, limit, truncated}` — name + creation time (`createdAt` is `null`, not `""`, when absent) |
| `bucket_info` | composite per bucket | policy (present/publicRead/publicWrite), versioning, lifecycle rules, encryption, quota, tags — per-probe failures degrade to an `errors` list |
| `bucket_policy_get` | `GetBucketPolicy` | verbatim policy JSON + anonymous-access s

references/cli-reference.md

# minio-aiops CLI reference

> The CLI is a convenience subset; the full 48-tool surface is via the MCP
> server (`minio-aiops mcp`). CLI writes delegate to the governed MCP twins,
> so they are audited + undo-recorded identically.

## Setup & diagnostics

```bash
minio-aiops init                    # wizard: endpoint, TLS, region, access key; secret key → encrypted store
minio-aiops doctor                  # config + secrets + live/ready + S3 auth + metrics reachability
minio-aiops doctor --skip-auth      # config/secrets checks only (no network)
minio-aiops overview                # health + capacity headline + exposure headline
```

## Secrets (encrypted store)

```bash
minio-aiops secret set <target>     # store/replace a secret key (prompted hidden)
minio-aiops secret list             # names only — values never shown
minio-aiops secret rm <target>
minio-aiops secret migrate          # import legacy plaintext .env keys
minio-aiops secret rotate-password  # re-encrypt under a new master password
```

## Reads

```bash
minio-aiops health check            # live + ready + cluster write-quorum
minio-aiops health status           # nodes/drives/capacity/buckets/objects
minio-aiops capacity rca            # flagship: capacity findings, cause + action
minio-aiops capacity usage          # per-bucket usage, biggest first
minio-aiops heal status             # flagship: erasure-set quorum risk + heal backlog
minio-aiops heal drives             # per-drive usage, fullest first
minio-aiops heal nodes              # per-node drive counts
minio-aiops bucket ls                # --limit caps the listing
minio-aiops bucket info <bucket>    # policy/versioning/lifecycle/encryption/quota/tags
minio-aiops bucket audit            # flagship: ranked exposure findings
minio-aiops bucket ilm-gap          # flagship: ILM gaps + reclaimable estimate
minio-aiops bucket objects <bucket> # objects under a prefix (--prefix, --limit)
minio-aiops bucket uploads <bucket> # incomplete multipart uploads
```

## Writes (all take --dry-run; destructive ones double-confirm)

```bash
minio-aiops bucket versioning-set <bucket> Enabled|Suspended
minio-aiops bucket policy-set <bucket> --file policy.json
minio-aiops bucket lifecycle-set <bucket> --expire-days 90 --noncurrent-days 30 [--prefix logs/]
minio-aiops bucket quota-set <bucket> <size-bytes>     # 0 clears
minio-aiops bucket purge-uploads <bucket> [--older-than-days 7]   # double confirm
minio-aiops bucket delete <bucket>                     # double confirm; refused unless empty
```

## MCP server

```bash
export MINIO_AIOPS_MASTER_PASSWORD=...   # required non-interactively (no TTY)
minio-aiops mcp                          # or: minio-aiops-mcp
```

Common options: `--target/-t <name>` selects a configured target (default: the
first one); `--dry-run` previews a write without executing.

## Truncation

Listing commands (`bucket ls`, `bucket objects`, `bucket uploads`,
`capacity usage`, `bucket audit`, `bucket ilm-gap`) retur

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.