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.

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).

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:

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

# 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:

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.