Erbina README | AllMCPs

erbina

A Claude-Code-only MCP server that bootstraps your dev environment from one prompt — install, wire, and verify CLI tools and other MCP servers from curated recipes, and see where every MCP server lives across your scopes.

An interactive Claude Code session driving erbina: one prompt inspects the httpie recipe to show the plan, then bootstraps it — installing via pipx and verifying http --version for real

Named after the Lusitanian goddess of boundaries and crossings — erbina is the threshold a tool crosses to become part of your environment. Sibling to ataegina (goddess of rebirth), which is also erbina's proof-of-concept recipe #1.

The recipe contract is the core idea. One server, eleven tools, and a curated set of 500+ recipes spanning cli-tools, scope-wiring mcp-servers, and profiles that bundle them (see the Recipe gallery). Each is one YAML file held to a conformance bar — schema + linter policy + a 100%-covered offline suite, plus a weekly job that actually installs it on macOS, Linux, and Windows — and adding one is the point.

Why this exists

Setting up a coding-agent environment is death by a thousand cuts: you install a CLI, hand-edit a config, add an MCP server — then find out it's in the wrong scope and isn't showing up. Claude Code spreads MCP config across up to four files in two apps, with no single place that knows what's installed where (anthropics/claude-code#27458, #8288, #5963).

erbina makes setup a thing an agent does for you, and proves worked:

It's an MCP server, so an agent must drive it. There is no human entry point — run it by hand and you get nothing. Nobody mistakes it for a manual installer that "should just work."
Recipes, not one-shot installs. Each entry is a contract: detect → install → configure → verify. Idempotent by construction — it detects what's already there and skips it, and success means the tool runs, not that a line was written to a file. Recipes also compose (requires: prerequisites, profiles that bundle a whole set) and cover the full lifecycle: update → re-verify → rollback, uninstall, and a doctor health-check over everything erbina installed.
Scope-aware. It knows about Claude Code's local / project / user scopes, wires MCP-server recipes into the right one, and audits all three so you finally have one place that answers "what's installed, and where?"
Proven, not just written. On top of the offline suite, a weekly (and on-demand) CI job bootstraps recipes for real against live package managers on macOS, Linux, and Windows — so a renamed brew formula, a dead URL, or a bad winget id is caught, not shipped.

Install

erbina is a single Python file run by uv (it declares its own dependencies inline — no venv to manage).

bash

git clone https://github.com/noahhyden/erbina
# register it with Claude Code (use --scope user to make it available everywhere)
claude mcp add erbina --scope user -- uv run --script /absolute/path/to/erbina/server.py

Then, in Claude Code, just ask: "use erbina to set up ataegina" — the agent inspects the recipe, shows you exactly what it will run, then bootstraps and verifies it.

Requirements: uv and Claude Code, on macOS, Linux, or Windows. Plus whatever a recipe's install method needs — typically brew on macOS, winget on Windows, or a language toolchain (cargo / go / pipx) or curl fallback elsewhere. Every method is guarded, so only one that actually exists on your machine ever runs.

Headless / CI usage

In an interactive session claude mcp add … (above) handles the trust prompt for you. A non-interactive claude -p run has no prompt to answer, so you load the server with --mcp-config and pre-approve erbina's tools with --allowedTools (their names are mcp__erbina__<tool>). Write an MCP config once:

json

// erbina.mcp.json
{ "mcpServers": { "erbina": {
  "command": "uv",
  "args": ["run", "--script", "/absolute/path/to/erbina/server.py"]
} } }

bash

# read-only: discover + inspect (nothing executes)
claude -p "use erbina to list recipes, then inspect ripgrep" \
  --mcp-config erbina.mcp.json --strict-mcp-config \
  --allowedTools mcp__erbina__list_recipes mcp__erbina__inspect_recipe

# install for real (add mcp__erbina__bootstrap to the allowlist)
claude -p "use erbina to bootstrap the modern-unix profile" \
  --mcp-config erbina.mcp.json --strict-mcp-config \
  --allowedTools mcp__erbina__bootstrap

--strict-mcp-config makes the run use only the servers in that file, so it never picks up your global config. Omit --allowedTools and a headless call can't call any tool — that's the one thing new CI users trip on.

Tools

Tool	What it does
`list_recipes`	List the curated recipes erbina can bootstrap — each with a `category` and search `tags` so you can tell at a glance what it's for.
`search_recipes`	Find a recipe by keyword and/or filter (`category`, `kind`) instead of scanning the whole list — ranked by relevance. E.g. "a JSON tool" or `category="kubernetes"`.
`list_categories`	A domain map of the registry — every category with a recipe, how many, and example tools. See what erbina covers at a glance, then drill in with `search_recipes(category=…)`.
`inspect_recipe`	Show exactly what bootstrapping a recipe would run — the consent surface. Nothing executes.
`bootstrap`	Run a recipe: detect → install → configure → verify, idempotently. `dry_run=true` returns the full plan without executing.
`check_updates`	Read-only report of whether installed tools have newer versions available, for recipes that declare a `version:` block. Pinned tools are flagged and excluded.
`update`	Upgrade an installed tool, then re-run `verify` as a safety net — on failure it rolls back (if the recipe supports it) or marks the tool broken. `dry_run=true` shows the command first.
`pin`	Pin (or unpin) a tool so automatic updates skip it. `update` refuses a pinned tool unless `force=true`.
`audit_scopes`	Read-only report of which MCP servers are configured in `local` / `project` / `user` scope, where each lives, and any name shadowed across scopes.
`find_dead_mcps`	Health-check every configured MCP server and flag the ones that fail to connect — stale/dead servers, annotated with the scope to remove them from. Read-only.
`remove_mcp`	Remove an MCP server by name (e.g. a dead one), auto-resolving its scope. `dry_run=true` shows the `claude mcp remove` command without running it.
`doctor`	Health-check the CLI tools erbina has installed (its state manifest): re-run each one's `detect` + `verify` and report healthy / missing / broken. Read-only; the CLI-tool counterpart to `find_dead_mcps`.
`uninstall`	Reverse a cli-tool install via the recipe's `uninstall:` block, confirm it's gone (re-run `detect`), and forget it in the state manifest. `dry_run=true` shows the command first. For MCP servers use `remove_mcp`.

The server's instructions tell the agent to always inspect (or dry-run) and show you the commands before executing — erbina shells out to package managers with real privileges (it runs as a sibling process, not under Claude Code's Bash sandbox), so consent before execution is the safety model.

How a recipe works

A recipe is four phases an agent executes. The proof-of-concept entry, recipes/ataegina.yaml:

yaml

detect:   { command: "ataegina --version", expect_exit: 0 }   # skip install if present
install:                                                       # first guard to pass wins
  methods:
    - { id: homebrew, when: "command -v brew", run: "brew install noahhyden/tap/ataegina" }
    - { id: curl,     when: "command -v curl", run: "curl -fsSL .../install.sh | sh" }
configure: { steps: [ { run: "ataegina init --yes", needs_project_dir: true, optional: true } ] }
verify:   [ { command: "ataegina --version", expect_exit: 0 } ]

A kind: mcp-server recipe instead wires a server into a chosen scope — its configure step is claude mcp add <name> --scope ${scope} -- …, where ${scope} is substituted from the scope you pass to bootstrap. See recipes/fetch.yaml. A kind: profile recipe installs nothing itself — it just requires: a curated set, so one prompt bootstraps the whole bundle.

Recipes can also declare optional blocks: requires: (prerequisites bootstrapped first), version: + update: / rollback: (auto-updates, with latest: as a command or the { github: owner/repo } shorthand), and uninstall: (teardown). Because each install method's when: guard runs in the host shell, methods are cross-platform — a winget method fires only on Windows, brew/cargo/curl only where they apply. The full schema is in SCHEMA.md.

[!WARNING] Windows support is limited and error-prone. macOS and Linux are the first-class targets. Most winget package ids were resolved in bulk against the winget catalog and are only spot-checked, so some may be wrong, out of date, or resolve to a look-alike package — a winget install can fail or, worse, install the wrong tool. The when: guard means a bad winget method fails cleanly rather than breaking a POSIX bootstrap, but treat Windows as best-effort: verify what got installed. Fixes are welcome.

Auto-updating tools

A recipe can opt into update checks by declaring a version: block (an installed current command and a latest source) and, optionally, update: / rollback: methods. Then:

check_updates compares installed vs latest (numeric/pre-release aware, via packaging) and reports what's out of date — it never claims an update it can't parse, skips pinned tools, and for a { github: … } source includes a release-notes link so you can review before applying.
update applies the upgrade and re-runs verify; if verify fails it rolls back to the recorded previous version (when the recipe declares a rollback: command) or marks the tool broken and returns a plan.
erbina records what it manages in a small state manifest (~/.erbina/state.json) — versions, install method, and pins.

Checks are agent-driven; you can also enable an opt-in SessionStart hook or a /schedule routine so the agent checks for you and asks before applying anything. See AUTO_UPDATE.md for the design, the version:/update:/ rollback: schema, and the trigger setup.

Recipe gallery

The curated registry today — 500+ recipes. Each links to its YAML; cli-tools install a binary, mcp-servers wire a server into a chosen Claude Code scope, and profiles bundle several recipes. (This list is kept in sync with recipes/ by a test. The bulk cli-tool entries are generated from scripts/recipe_data.py.)

CLI tools — the marquee set

ataegina — collision-free dev environments per git worktree
bat — a cat clone with syntax highlighting and Git integration
bottom — a cross-platform graphical process/system monitor
delta — a syntax-highlighting pager for git, diff, and grep output
difftastic — a structural (syntax-aware) diff tool
dust — a more intuitive version of du
eza — a modern, maintained replacement for ls
fd — a fast, friendly alternative to find
gh — GitHub's official command-line tool
httpie — a human-friendly command-line HTTP client
hyperfine — a command-line benchmarking tool
jq — command-line JSON processor
lazygit — a simple terminal UI for git commands
procs — a modern replacement for ps
ripgrep — blazing-fast recursive search
sd — intuitive find & replace (a friendlier sed)
tealdeer — a very fast tldr client (simplified man pages)
tokei — count your code, quickly
uv — an extremely fast Python package and project manager
yq — a portable command-line YAML/JSON/XML processor
zoxide — a smarter cd command that learns your habits

CLI tools — the full registry (500+, bulk-curated, kept in sync with recipes/ by scripts/gen_recipes.py)

ack — a grep-like search tool optimized for source code
act — run your GitHub Actions locally
ag — a code-searching tool similar to ack, but faster (ag)
age — a simple, modern and secure encryption tool
aichat — all-in-one LLM CLI tool
alex — catch insensitive, inconsiderate writing
ali — generate HTTP load and plot the results in real-time
angle-grinder — slice and dice logs on the command line (agrind)
ansible — a radically simple IT automation platform
argocd — the CLI for Argo CD, declarative GitOps continuous delivery for Kubernetes
aria2 — a lightweight multi-protocol and multi-source download utility (aria2c)
artillery — a modern load testing and smoke testing toolkit
asciidoctor — a fast, open-source text processor for converting AsciiDoc content
asciinema — record and share terminal sessions
asdf — manage multiple runtime versions with a single CLI tool
ast-grep — a fast and polyglot tool for code structural search, lint and rewriting
atmos — universal tool for DevOps and cloud automation
atuin — magical shell history
autoconf — a tool for producing configure scripts for building software
autojump — a faster way to navigate your filesystem
automake — a tool for automatically generating Makefile.in files
autopep8 — automatically formats Python code to conform to the PEP 8 style guide
aws-sam-cli — build and test serverless applications with the AWS Serverless Application Model (sam)
aws-vault — a vault for securely storing and accessing AWS credentials
awscli — the AWS Command Line Interface (aws)
axel — a light command-line download accelerator
azure-cli — the command-line tools for managing Azure resources (az)
bacon — a background rust code checker
bandit — a tool designed to find common security issues in Python code
bandwhich — terminal bandwidth utilization tool
bash — the GNU Bourne-Again SHell
bats — Bash Automated Testing System
bc — an arbitrary-precision calculator language
beets — the music geek's media organizer (beet)
biome — a performant toolchain for web projects: format, lint and more
black — the uncompromising Python code formatter
borg — deduplicating archiver with compression and encryption
bpython — a fancy interface to the Python interpreter
broot — a new way to see and navigate directory trees
brotli — a generic-purpose lossless compression algorithm
btop — a monitor of resources
buf — the best way to work with Protocol Buffers
buku — a powerful bookmark manager and mini web-tagger
bun — an incredibly fast JavaScript runtime, bundler, transpiler and package manager
caddy — fast and extensible multi-platform web server with automatic HTTPS
calcurse — a text-based calendar and scheduling application
carthage — a simple, decentralized dependency manager for Cocoa
ccache — a fast C/C++ compiler cache
cdk — define cloud infrastructure using familiar programming languages (cdk)
chafa — image-to-text converter for terminal graphics
cheat — create and view interactive cheatsheets on the command line
checkov — prevent cloud misconfigurations by scanning infrastructure as code
chezmoi — manage your dotfiles across multiple diverse machines, securely
choose — a human-friendly and fast alternative to cut and (sometimes) awk
clang-format — a tool to format C, C++, Objective-C and related code
cloudflared — Cloudflare Tunnel client
cmake — a cross-platform family of tools designed to build, test and package software
cocoapods — the dependency manager for Swift and Objective-C Cocoa projects (pod)
code2prompt — a CLI tool to convert your codebase into a single LLM prompt
codespell — fix common misspellings in text files and source code
colima — container runtimes on macOS (and Linux) with minimal setup
colordiff — a tool to colorize diff output
commitizen — create committing rules, bump versions and generate changelogs (cz)
commitlint — lint commit messages against your commit convention
composer — dependency manager for PHP
concurrently — run multiple commands concurrently
conftest — write tests against structured configuration data using OPA/Rego
consul — service networking across any cloud
cookiecutter — a command-line utility that creates projects from templates
cosign — container signing, verification and storage in an OCI registry
cpanminus — get, unpack, build and install modules from CPAN (cpanm)
cppcheck — a static analysis tool for C/C++ code
crane — a tool for interacting with remote images and registries
croc — securely send files and folders from one computer to another
crystal — a language for humans and computers, with Ruby-like syntax and native speed
cspell — a spell checker for code
csvkit — a suite of command-line tools for converting to and working with CSV (csvlook)
csvtk — a cross-platform, efficient and practical CSV/TSV toolkit
ctop — top-like interface for container metrics
curl — a command-line tool for transferring data with URLs
dasel — select, put and delete data from JSON, TOML, YAML, XML and CSV
datamash — a command-line program which performs basic numeric, textual and statistical operations on input textual data
datasette — an open source multi-tool for exploring and publishing data
dbmate — a lightweight, framework-agnostic database migration tool
degit — straightforward project scaffolding
delve — a debugger for the Go programming language (dlv)
deno — a modern runtime for JavaScript and TypeScript
devspace — a client-only developer tool for fast Kubernetes development
direnv — unclutter your .profile with per-directory environments
diskonaut — terminal disk space navigator
dive — a tool for exploring a docker image and layer contents
doctl — the official command-line interface for the DigitalOcean API
doctoc — generates a table of contents for markdown files
dog — a command-line DNS client
doggo — a modern command-line DNS client (like dig) written in Go
dos2unix — text file format converter between DOS/Mac and Unix line endings
dotenv-linter — a lightning-fast linter for .env files
doxygen — the de facto standard tool for generating documentation from annotated C++ sources
dprint — a pluggable and configurable code formatting platform
dua — a tool to conveniently learn about disk usage
duckdb — an in-process SQL OLAP database management system
duf — disk usage/free utility, a better df alternative
dysk — a linux utility to get information on filesystems, like df but better
eksctl — the official CLI for Amazon EKS
elixir — a dynamic, functional language for building scalable and maintainable applications
esbuild — an extremely fast JavaScript bundler and minifier
eslint — find and fix problems in your JavaScript code
eva — a simple calculator REPL, similar to bc
exiftool — read, write and edit meta information in a wide variety of files
fastfetch — a fast, feature-rich system information tool
fastlane — the easiest way to automate building and releasing iOS and Android apps
fastmod — a fast partial replacement for the codemod tool
fblog — a small command-line JSON log viewer
fclones — an efficient duplicate file finder and remover
fend — an arbitrary-precision unit-aware calculator
ffmpeg — a complete solution to record, convert and stream audio and video
ffuf — fast web fuzzer written in Go
firebase-tools — the Firebase command-line interface (firebase)
fish — the friendly interactive shell
flac — the reference implementation of the Free Lossless Audio Codec
flake8 — the modular source code checker for Python
flatbuffers — a cross-platform serialization library for memory-efficient data (flatc)
flyctl — the command-line interface for Fly.io
fnm — fast and simple Node.js version manager
fq — jq for binary formats
freeze — generate images of code and terminal output
fswatch — a cross-platform file change monitor with multiple backends
fx — terminal JSON viewer and processor
fzf — a command-line fuzzy finder
gallery-dl — download image galleries and collections from several image hosting sites
gawk — the GNU implementation of the AWK programming language
gcovr — generate code coverage reports with gcc/gcov
gdu — a fast disk usage analyzer with a console interface written in Go
genact — a nonsense activity generator
ghostscript — an interpreter for PostScript and PDF (gs)
ghq — manage remote repository clones
gifski — the highest-quality GIF encoder based on pngquant
git-absorb — automatically absorb staged changes into your recent commits
git-cliff — a highly customizable changelog generator
git-filter-repo — quickly rewrite git repository history
git-lfs — git extension for versioning large files
git-town — generic, high-level git workflow support
gitleaks — detect secrets in code
gitlint — a git commit message linter written in Python
gitmoji — an interactive command-line tool for using emojis on commits (gitmoji)
gitu — a TUI git client inspired by Magit
gitui — blazing-fast terminal UI for git
glab — an open-source GitLab CLI tool
glances — a cross-platform system monitoring tool
gleam — a friendly language for building type-safe systems that scale
glow — render markdown on the CLI, with style
gnuplot — a portable command-line driven graphing utility
goaccess — a real-time web log analyzer and interactive viewer
gobuster — directory/file, DNS and vhost busting tool
golangci-lint — fast linters runner for Go
gopass — the slightly more awesome standard unix password manager for teams
goreleaser — deliver Go binaries as fast and easily as possible
gpg-tui — a terminal user interface for GnuPG
gping — ping, but with a graph
gradle — an open-source build automation tool focused on flexibility and performance
graphviz — graph visualization software (dot)
grex — generate regular expressions from user-provided examples
gron — make JSON greppable
grpcurl — like cURL, but for gRPC
grype — a vulnerability scanner for container images and filesystems
gum — a tool for glamorous shell scripts
hadolint — a smarter Dockerfile linter
hatch — a modern, extensible Python project manager
hcloud — a command-line interface for Hetzner Cloud
helix — a post-modern modal text editor
helm — the Kubernetes package manager
helmfile — deploy Kubernetes Helm charts declaratively
hexyl — a command-line hex viewer
hgrep — human-friendly grep with a rich display
hlint — a tool for suggesting possible improvements to Haskell code
hostctl — a CLI tool to manage /etc/hosts with ease
howdoi — instant coding answers via the command line
htmlhint — the static code analysis tool you need for your HTML
htmlq — like jq, but for HTML
htop — an interactive process viewer
http-server — a simple, zero-configuration command-line HTTP server
hugo — the world's fastest framework for building websites
hurl — run and test HTTP requests with plain text
hwatch — a modern alternative to the watch command that records execution results
icdiff — improved colored diff, side-by-side
imagemagick — create, edit, compose or convert digital images (magick)
infracost — cloud cost estimates for Terraform in pull requests
iperf3 — a TCP, UDP and SCTP network bandwidth measurement tool
ipython — a powerful interactive Python shell
isort — a Python utility to sort imports alphabetically and automatically
jaq — a jq clone focused on correctness, speed and simplicity
jbang — unleash the power of Java for scripting
jc — convert the output of many CLI tools and file types to JSON
jekyll — a blog-aware static site generator in Ruby
jenv — manage your Java environment
jless — a command-line JSON viewer
jnv — an interactive JSON filter using jq
jo — a small utility to create JSON objects
joshuto — a ranger-like terminal file manager written in Rust
jpegoptim — utility to optimize and compress JPEG files
json-server — get a full fake REST API with zero coding in less than 30 seconds
julia — a high-level, high-performance dynamic language for technical computing
jupytext — Jupyter notebooks as markdown documents, Julia, Python or R scripts
just — a handy command runner
k3d — little helper to run k3s in Docker
k6 — a modern load testing tool for engineering teams
k9s — Kubernetes CLI to manage your clusters in style
kalker — a scientific calculator that supports math-like syntax
kdash — a simple and fast dashboard for Kubernetes
khal — a standards-based CLI and terminal calendar program
kind — Kubernetes IN Docker
kmon — Linux kernel manager and activity monitor
ko — build and deploy Go applications on Kubernetes
kompose — go from Docker Compose to Kubernetes
kondo — cleans dependencies and build artifacts from your projects
kopia — a fast and secure open-source backup/restore tool
ktlint — an anti-bikeshedding Kotlin linter with built-in formatter
kube-linter — a static analysis tool that checks Kubernetes YAML and Helm charts
kubeconform — a fast Kubernetes manifest validation tool
kubectl — the Kubernetes command-line tool
kubectx — faster switching between Kubernetes contexts
kubescape — a Kubernetes security platform for scanning clusters, YAML files and Helm charts
kubeseal — a CLI to encrypt secrets into SealedSecrets for Kubernetes
kustomize — customization of Kubernetes YAML configurations
lazydocker — a simple terminal UI for docker and docker-compose
lefthook — a fast and powerful git hooks manager
lerna — a tool for managing JavaScript projects with multiple packages
lighthouse — automated auditing, performance metrics and best practices for the web
litecli — a command-line client for SQLite with auto-completion and syntax highlighting
lnav — the logfile navigator
localstack — a fully functional local cloud stack emulating AWS
localtunnel — expose your localhost to the world (lt)
locust — a modern load testing framework, define user behaviour with Python code
lolcat — rainbows and unicorns in your terminal
lsd — the next-gen ls command
luarocks — the package manager for Lua modules
lz4 — extremely fast lossless compression algorithm
macchina — a fast, minimal and customizable system information tool
magic-wormhole — get things from one computer to another, safely
markdownlint-cli2 — a fast, flexible, configuration-based command-line interface for linting markdown
mask — a CLI task runner defined by a simple markdown file
maven — a build automation and project management tool for Java (mvn)
mc — a modern replacement for ls, cp, mirror and more for object storage (mc)
mcfly — an intelligent shell history search
mdbook — create book-like documentation from markdown files
mdcat — cat for markdown
mediainfo — display technical and tag data for video and audio files
meson — a fast and user-friendly build system
micro — a modern and intuitive terminal-based text editor
miller — like awk, sed, cut, join and sort for CSV, TSV and JSON (mlr)
minikube — run Kubernetes locally
miniserve — a small, self-contained static file server
mise — the front-end to your dev env
mitmproxy — an interactive HTTPS proxy for intercepting, inspecting and modifying traffic
mkcert — a simple tool for making locally-trusted development certificates
mkdocs — project documentation with markdown
mkvtoolnix — tools to create, alter and inspect Matroska files (mkvmerge)
mob — a fast way to switch between roles when doing remote mob programming
mods — AI on the command line
mongosh — the MongoDB Shell, a modern command-line interface for MongoDB
mosh — the mobile shell, a remote terminal application that supports roaming
mprocs — run multiple commands in parallel with a TUI
mtr — a network diagnostic tool combining ping and traceroute
mycli — a command line client for MySQL with auto-completion and syntax highlighting
mypy — optional static typing for Python
nano — a small, friendly text editor for the terminal
navi — an interactive cheatsheet tool for the CLI
nbdime — tools for diffing and merging of Jupyter notebooks
ncdu — NCurses disk usage
neovim — hyperextensible Vim-based text editor (nvim)
nerdctl — contaiNERD CTL, a Docker-compatible CLI for containerd
netlify — the command-line interface for Netlify
newman — a command-line collection runner for Postman
nim — an efficient, expressive, elegant statically typed compiled language
ninja — a small build system with a focus on speed
nmap — the network mapper, a utility for network discovery and security auditing
nodemon — monitor for changes and automatically restart your node app
nomad — an easy-to-use, flexible, and performant workload orchestrator
nox — flexible test automation with Python
npkill — easily find and remove old and heavy node_modules folders
npm-check-updates — upgrade your package.json dependencies to the latest versions (ncu)
nuclei — fast and customizable vulnerability scanner based on simple YAML templates
numbat — a statically typed programming language for scientific computations with units
nushell — a new type of shell
ocrmypdf — adds an OCR text layer to scanned PDF files
octave — a high-level language primarily intended for numerical computations
oha — HTTP load generator with a realtime TUI
ollama — get up and running with large language models locally
onefetch — a git repository summary in your terminal
opa — Open Policy Agent, general-purpose policy engine
opam — the OCaml package manager
opentofu — an open-source Terraform-compatible infrastructure as code tool
oras — OCI registry as storage
ormolu — a formatter for Haskell source code
ouch — painless compression and decompression on the command line
ov — a feature-rich terminal pager
oxipng — a multithreaded lossless PNG compression optimizer
pa11y — your automated accessibility testing pal
packer — build automated machine images
pandoc — a universal document converter
papermill — parameterize, execute and analyze Jupyter notebooks
parallel — GNU parallel, a shell tool for executing jobs in parallel
parcel — the zero-configuration build tool for the web
pastel — a tool to generate, analyze, convert and manipulate colors
pdm — a modern Python package and dependency manager supporting the latest PEP standards
pgcli — a command line interface for Postgres with auto-completion and syntax highlighting
pigz — a parallel implementation of gzip for modern multi-processor machines
pip-audit — audit Python environments and dependency trees for known vulnerabilities
pipdeptree — display a dependency tree of installed Python packages
pipenv — Python development workflow for humans
pipx — install and run Python applications in isolated environments
pkg-config — a helper tool used when compiling applications and libraries
playwright — reliable end-to-end testing for modern web apps
pm2 — a production process manager for Node.js applications with a built-in load balancer
pngquant — a command-line utility to convert 24/32-bit PNGs to 8-bit paletted PNGs
pnpm — fast, disk space-efficient package manager
poetry — Python packaging and dependency management made easy
popeye — a Kubernetes cluster resource sanitizer
pre-commit — a framework for managing multi-language pre-commit hooks
presenterm — markdown terminal slideshows
prettier — an opinionated code formatter
prisma — next-generation Node.js and TypeScript ORM
proselint — a linter for prose
protobuf — Protocol Buffers, Google's data interchange format (protoc)
protolint — a pluggable linter and fixer to enforce Protocol Buffer style and conventions
pspg — a unix pager optimized for psql and other tabular output
ptpython — a better Python REPL
pueue — a command-line task management tool for sequential and parallel execution
pulumi — infrastructure as code in your favorite language
pv — pipe viewer, monitor the progress of data through a pipe
pyenv — simple Python version management
pyinstaller — bundles a Python application and all its dependencies into a single package
pylint — a static code analyser for Python
pyright — a fast static type checker for Python
qpdf — a command-line program that does structural, content-preserving transformations on PDF files
qsv — a blazing-fast CSV data-wrangling toolkit
r — a free software environment for statistical computing and graphics (R)
radon — various code metrics for Python code
ranger — a VIM-inspired file manager for the console
rav1e — the fastest and safest AV1 encoder
rbenv — manage your app's Ruby environment
rclone — rsync for cloud storage
redis — an in-memory data store; ships the redis-cli client
release-it — automate versioning and package publishing
restic — fast, secure, efficient backup program
rich-cli — a command-line toolbox for fancy output (rich)
ripsecrets — a command-line tool to prevent committing secret keys into your source code
rlwrap — a readline wrapper for any command
rnr — a command-line tool to batch-rename files and directories
rollup — a module bundler for JavaScript
rsync — a fast, versatile, remote (and local) file-copying tool
rubocop — a Ruby static code analyzer and formatter, based on the community style guide
ruby — a dynamic, open-source programming language with a focus on simplicity and productivity
ruff — an extremely fast Python linter and formatter
rustic — fast, encrypted and deduplicated backups powered by Rust
rustscan — the modern port scanner
s-tui — a terminal UI for monitoring your computer's CPU temperature, frequency, power and utilization
s3cmd — command-line tool for managing Amazon S3 and compatible object stores
sass — the reference implementation of Sass, written in Dart
sbcl — Steel Bank Common Lisp, a high-performance Common Lisp compiler
scc — a fast and accurate code counter with complexity calculations
sccache — shared compilation cache
scmpuff — numeric shortcuts for common git commands
scrapy — a fast high-level web crawling and web scraping framework for Python
semantic-release — fully automated version management and package publishing
semgrep — lightweight static analysis for many languages
seqkit — a cross-platform and ultrafast toolkit for FASTA/Q file manipulation
serie — a rich git commit graph in your terminal
serve — static file serving and directory listing
serverless — build and deploy serverless applications across cloud providers
shellcheck — a static analysis tool for shell scripts
shellharden — a bash syntax highlighter that encourages good coding practices
shellspec — a full-featured BDD unit testing framework for POSIX shells
shfmt — a shell parser, formatter, and interpreter
silicon — create beautiful images of your source code
skopeo — work with remote container images registries
sops — simple and flexible tool for managing secrets
sox — the Swiss Army knife of sound processing programs
spectral — a flexible JSON/YAML linter for OpenAPI, AsyncAPI and more
speedtest — command-line internet bandwidth tester (speedtest.net)
speedtest-cli — command line interface for testing internet bandwidth using speedtest.net
sphinx — a documentation generator (sphinx-build)
sqlc — generate type-safe code from SQL
sqlfluff — a modular SQL linter and auto-formatter with support for multiple dialects
sqlite — a small, fast, self-contained SQL database engine (sqlite3)
sqlite-utils — CLI tool and Python library for manipulating SQLite databases
sshuttle — a transparent proxy server that works as a poor man's VPN over ssh
stack — the Haskell Tool Stack, a cross-platform build tool for Haskell projects
starship — the minimal, blazing-fast, cross-shell prompt
step — a zero-trust swiss-army knife for working with certificates and CAs
stern — multi pod and container log tailing for Kubernetes
stow — GNU Stow, a symlink farm manager
streamlink — a CLI utility that pipes video streams into a video player
stylelint — a mighty CSS linter that helps you avoid errors and enforce conventions
stylua — an opinionated Lua code formatter
subfinder — fast passive subdomain enumeration tool
svgo — Node.js tool for optimizing SVG files
svu — semantic version util
swiftformat — a command-line tool and Xcode extension for formatting Swift code
swiftlint — a tool to enforce Swift style and conventions
syft — generate a software bill of materials from container images and filesystems
systeroid — a more powerful alternative to sysctl
tailscale — the easiest, most secure way to use WireGuard and 2FA
tailwindcss — a utility-first CSS framework CLI
taplo — a versatile, feature-rich TOML toolkit
task — a task runner / build tool that aims to be simpler and easier to use than make
television — a cross-platform, fast and extensible fuzzy finder
termshark — a terminal UI for tshark, inspired by Wireshark
terraform-docs — generate documentation from Terraform modules
terragrunt — a thin wrapper for Terraform for keeping configurations DRY
terrascan — detect compliance and security violations across infrastructure as code
tesseract — an optical character recognition (OCR) engine
textlint — the pluggable natural language linter for text and markdown
tflint — a pluggable Terraform linter
tfsec — security scanner for your Terraform code
thefuck — magnificent app that corrects errors in previous console commands
thrift — the Apache Thrift compiler for scalable cross-language services
tig — text-mode interface for git
tilt — local Kubernetes development with no stress
timg — a terminal image and video viewer
tmux — a terminal multiplexer
tmuxinator — create and manage complex tmux sessions easily
tmuxp — a session manager for tmux
topgrade — upgrade everything with one command
tox — a generic virtualenv management and test command line tool
tree — a recursive directory listing command
tree-sitter — an incremental parsing system for programming tools
trippy — a network diagnostic tool (trip)
trivy — a comprehensive and versatile security scanner
trunk — build, bundle and ship your Rust WASM application to the web
ts-node — TypeScript execution and REPL for Node.js
tsx — TypeScript execute: run TypeScript & ESM in Node.js
tuc — cut with a lot of features (a hopefully better cut)
twine — a utility for publishing Python packages on PyPI
typescript — JavaScript with syntax for types
typos — source code spell checker
typst — a new markup-based typesetting system that is powerful and easy to learn
ugrep — ultra-fast grep with interactive query UI
usql — a universal command-line interface for SQL databases
vale — a syntax-aware linter for prose
vault — manage secrets and protect sensitive data
vdirsyncer — synchronize calendars and addressbooks between servers and the local filesystem
vector — a high-performance observability data pipeline
vercel — the command-line interface for Vercel
verdaccio — a lightweight private npm proxy registry
verilator — the fastest Verilog/SystemVerilog simulator
vhs — your CLI home video recorder
viddy — a modern watch command with time machine and pause
vifm — a file manager with curses interface, providing Vi[m]-like environment
vim — the ubiquitous, highly configurable modal text editor
virtualenv — a tool to create isolated Python environments
visidata — a terminal interface for exploring and arranging tabular data (vd)
viu — a terminal image viewer with native support for iTerm and Kitty
vivid — a generator for LS_COLORS with support for multiple color themes
volta — the hassle-free JavaScript tool manager
vulture — find dead code in Python programs
wasm-pack — build, test and publish Rust-generated WebAssembly
wasmer — the leading WebAssembly runtime supporting WASI and Emscripten
wasmtime — a fast and secure runtime for WebAssembly
watchexec — run commands when files change
watchman — a file watching service from Meta
webpack — a static module bundler for modern JavaScript applications
websocat — netcat, curl and socat for WebSockets
wget — the non-interactive network downloader
wireguard-tools — the wg command-line tools for WireGuard VPN (wg)
wrangler — the command-line interface for building Cloudflare Workers
xcodegen — a command-line tool that generates your Xcode project from a spec and your folder structure
xh — a friendly and fast tool for sending HTTP requests
xonsh — a Python-powered shell
xplr — a hackable, minimal, fast TUI file explorer
xsv — a fast CSV command line toolkit
xz — a general-purpose data compression tool with high compression ratio
yadm — yet another dotfiles manager
yamllint — a linter for YAML files
yapf — a formatter for Python files from Google
yarn — fast, reliable and secure dependency management for JavaScript
yazi — blazing-fast terminal file manager
yt-dlp — a feature-rich command-line audio/video downloader
zellij — a terminal workspace and multiplexer
zig — a general-purpose programming language and toolchain for maintaining robust software
zola — a fast static site generator in a single binary with everything built-in
zsh — the Z shell, an extended Bourne shell with many improvements
zstd — Zstandard, a fast real-time compression algorithm

Profiles — bundle several recipes; bootstrap resolves them all

data — command-line data wrangling (jq, yq, dasel, duckdb, miller, csvkit, qsv)
git-power — git power-tools (gh, lazygit, delta, difftastic, git-lfs, tig, git-cliff)
kubernetes — Kubernetes toolkit (kubectl, helm, k9s, kustomize, stern, kubectx, kind, minikube)
modern-unix — a curated set of modern CLI replacements (ripgrep, fd, bat, eza, dust, zoxide)
node-dev — Node.js / JS toolchain (fnm, pnpm, bun, esbuild, biome, tsx)
python-dev — Python toolchain (uv, ruff, black, mypy, poetry, pre-commit, ipython)
security — security & supply-chain scanners (trivy, grype, syft, gitleaks, ripsecrets, semgrep)

MCP servers — wire a server into a chosen Claude Code scope

context7 — up-to-date library docs & code examples in context (Upstash)
everything — official MCP reference/test server exercising the full protocol
fetch — official MCP server for retrieving web content
filesystem — official MCP server for scoped local file access
git — official MCP server for Git repository operations
memory — official MCP server for a persistent knowledge graph
playwright-mcp — browser automation via Microsoft Playwright
sequentialthinking — official MCP server for structured step-by-step reasoning
time — official MCP server for time & timezone conversions

Adding a recipe

Drop a <id>.yaml in recipes/ following SCHEMA.md. kind: cli-tool installs a binary; kind: mcp-server additionally wires it into the chosen Claude Code scope; kind: profile just bundles others via requires:. Keep detect cheap and verify honest (prove it runs).

What this is not

Not a package manager you run by hand (that's mcpm / brew / aqua), not a discovery registry (that's Smithery), and not a way to "rebuild my laptop deterministically" (use Nix / chezmoi / a Brewfile — an LLM-driven setup is the wrong tool for reproducible provisioning). erbina's niche is the intersection: agent-run, verify-on-install recipes that span CLI tools and MCP servers, aware of Claude Code's scopes.

Safety model

erbina runs as an ordinary sibling process of Claude Code — not inside its Bash sandbox — so a recipe's commands execute with your real privileges. The safety model is consent before execution: inspect_recipe and bootstrap(dry_run=true) show you the exact commands first, and the server instructs the agent to surface that plan before any real run. Only bootstrap recipes you've read. See SECURITY.md for the full trust model and how to report a vulnerability.

Contributing

The most useful contribution is usually a new recipe — one YAML file in recipes/. See CONTRIBUTING.md for the ground rules and how to smoke-test with an in-memory FastMCP client, SCHEMA.md for the recipe contract, and CHANGELOG.md for what's landed. By participating you agree to the Code of Conduct.

License

MIT. See LICENSE.