Commands reference

Marea's CLI is assembled from plugins. Every top-level command — and many of the flags on existing ones — comes from a plugin's Marea.Plugins.Base.marea_config_args/1 callback. This page is the index: the core command tree, the global options shared by every leaf subcommand, and links to each plugin's reference for the full subcommand and flag list.

The command tree

marea
├── setup    init-umbrella | init-release
├── build    clean | local | deps | release            (Marea.Plugins.Build, base)
│            | docker | show-dockerfile                (Marea.Plugins.Docker, optional)
│            | show-docker-versions                    (Marea.Plugins.Docker, optional)
│            | helm                                    (Marea.Plugins.Helm, optional)
├── run      local | release | docker
├── mcp      serve | tools | call                      (Marea.Plugins.Mcp, base)
├── schema   show [--json]
├── helm     chart | list | history | values | template | upgrade
│            | delete | rollback                       (Marea.Plugins.Helm, optional)
├── k8s      describe | logs | shell | console | restart | remote
│                                                      (Marea.Plugins.K8s, optional)
├── aws      ecr {login | login-docker | list | create | delete}
│            route53 {get | list | create | delete | update-deploy-domains}
│            s3 {sync-in | sync-out}                   (Marea.Plugins.Aws, optional)
└── …        anything contributed by plugins listed in marea.yaml

setup, build, run, mcp, schema (plus base) are part of @base_plugins and always loaded. The build parent is owned by Marea.Plugins.Build, but multiple plugins extend it: Docker adds build docker / show-dockerfile / show-docker-versions, Helm adds build helm — both opt-in. helm, k8s, aws, and any custom plugin also live behind a plugins: entry in marea.yaml (plugin_deps: resolves the obvious chains, e.g. listing Helm brings in Docker and Build).

Every leaf subcommand listed above is also exposed as an MCP tool when marea mcp serve is running — the tool name is the joined path (helm_upgrade, aws_ecr_login, build_docker, …) and its JSON-Schema input is derived from the same option/flag spec used by the CLI. See the MCP Plugin guide.

marea --help (or marea help <command>) prints the live tree for the project — it is built from whatever plugins are loaded, so it is always authoritative.

Global options and flags

These are added by Marea.Plugins.Base and propagated by Marea.Config.Args into every leaf subcommand, so you can pass them anywhere on the command line.

Many subcommands also share a smaller set of common options provided by Marea.Config.Args and reused across plugins:

Marea remembers the last --deploy and --release you used in <marea_dir>/last_values and reuses them as defaults — most follow-up commands need neither.

Per-plugin commands

Each plugin's reference page lists every subcommand it contributes, the flags and options it accepts, and the YAML schema fields it adds. Start here:

Each plugin doc follows the same shape: a "Commands" tree, one section per subcommand with its options and flags, and the schema fields it adds to marea.yaml.

Adding your own commands

A plugin can contribute three things to the CLI:

1. A new top-level command (or subcommand under an existing one), added through Marea.Config.Args.add_subcommands/2 inside its Marea.Plugins.Base.marea_config_args/1 callback.
2. An extra flag or option on an existing command, by enriching the same args map (listing your plugin before the one you want to influence in plugins: so it sees the chain first). The same merge rules let several plugins extend a shared parent — that's how Build, Docker, and Helm all contribute children under build.
3. Extra global options/flags, by setting global: true on the spec — Args.build_optimus/1 injects globals into every leaf subcommand automatically.

Command dispatch goes through the Marea.Plugins.Base.marea_cmd/2 chain: each plugin either matches a command prefix (e.g. [:helm | rest]) or returns :cont to pass control on. The full callback shape, return values, and chain ordering rules are documented in Plugin Development, and the underlying mechanism in Architecture.

Where to go next

• Plugin Development — write a plugin that contributes commands, flags, or schema fields.
• Architecture — how Marea.Plugins.Base.marea_config_args/1 and Marea.Plugins.Base.marea_cmd/2 actually compose.
• marea.yaml Reference — the config that drives the commands listed above.