The cameleer command line: every command and flag

Q: How do I run every route file in a folder?

Run cameleer run in that folder without file names. It skips application* files and *.test.yaml files.

Q: How do I run a route once and exit?

Give it a limit: --max-messages 1 stops after one message, --max-seconds N after N seconds and --max-idle-seconds N when nothing has happened for N seconds. A timer with repeatCount plus --max-idle-seconds ends a batch job.

Q: How do I see what a running integration is doing?

cameleer ps lists it, cameleer get routes shows each route's message counts, cameleer log --follow prints its log and cameleer trace prints each message as it moves through the routes. In a container, start it with --console and use cameleer get ... --url.

Q: Where is camel run?

Cameleer's command is cameleer, not camel, so it does not clash with Apache Camel's Camel JBang. The subcommands have the same names.

Q: How do I list a component's options?

cameleer catalog components lists the schemes; the options of each are on its page under components, with the same names as in Apache Camel.

cameleer is Cameleer's command line, a native counterpart of Apache Camel's Camel JBang: cameleer run runs route files, init writes a starter route, validate checks routes without running them, test runs route tests, export turns routes into a Rust project, and ps, get, cmd, log, trace, stop and tool manage integrations that are already running. This page lists every command and every flag.

Applies to: the cameleer binary (cargo install cameleer-main, the Docker image pmsudhi/cameleer) · Apache Camel: Camel JBang

The commands follow Camel JBang's names. Camel JBang's own command is camel; Cameleer's is cameleer, so both can be installed side by side. In Docker the image's entry point is the binary, so docker run pmsudhi/cameleer <command> ... runs the same commands.

Commands at a glance

command	what it does	Camel JBang
`run`	run route files until stopped or a limit is reached	`camel run`
`init`	write a starter route, Kamelet, Pipe, Integration or properties file	`camel init`
`validate`	check route files without running them	(none)
`schema`	print the JSON Schema of the YAML DSL	(none)
`test`	run YAML test files against routes	`camel test` (Citrus)
`export`	write a standalone Cargo project that embeds the routes	`camel export`
`bind`	write a Pipe that binds a source to a sink	`camel bind`
`catalog`	list components, languages or Kamelets	`camel catalog`
`ps`	list running integrations	`camel ps`
`stop`	stop one or all running integrations	`camel stop`
`get`	show routes, context, health or endpoints	`camel get`
`cmd`	start, stop, suspend or resume routes, reset statistics, reload	`camel cmd`
`log`	print or follow an integration's log	`camel log`
`trace`	turn message tracing on or off and print traced messages	`camel trace`
`tool`	AI tools of a running integration: kill switch and approvals	(none)
`version`	print the version (a reduced build also lists its component families)	`camel version`
`help`	print the usage summary	`camel --help`

cameleer --version, -v, --help and -h work too. A command exits with 0 on success and 1 on failure, with the error on standard error; validate also uses 2 for a usage error.

Options take their value as the next argument or after =: --port 9090 and --port=9090 are the same. An unknown option is an error that prints the usage.

cameleer run

text

cameleer run [files...] [--properties FILE] [--profile P] [--dev] [--name N] [--background]
             [--max-seconds N] [--max-messages N] [--max-idle-seconds N] [--prop key=value]
             [--log-level LEVEL] [--console] [--port N] [--trace] [--mcp | --mcp-stdio]
             [--mcp-expose PATTERNS]

Runs route files: Camel YAML (.yaml, .yml), Camel XML (.xml), Kamelets, Pipes and Camel K Integration resources. Without files it runs every .yaml, .yml and .xml file of the current directory, except application* files and *.test.yaml test files. It runs until it is stopped (Ctrl+C, SIGTERM, cameleer stop) or a limit set with --max-seconds, --max-messages or --max-idle-seconds is reached.

flag	what it does	same as
`--properties FILE`	read this file instead of the `application.*` files of the current directory
`--profile P`	activate a profile: reads `application-P.properties` and `%P.` keys	`camel.main.profile`
`--dev`	reload route files when they change, and activate the `dev` profile unless `--profile` is given	`camel.main.dev-reload=true`
`--name N`	the integration's name, shown by `ps` and used to select it; defaults to the first file's name without extension	`camel.main.name`
`--background`	start in the background, print the process id and return
`--max-seconds N`	stop after N seconds	`camel.main.duration-max-seconds`
`--max-messages N`	stop after N messages	`camel.main.duration-max-messages`
`--max-idle-seconds N`	stop after N seconds without a message	`camel.main.duration-max-idle-seconds`
`--prop key=value`	set any configuration key; repeat it for several
`--log-level LEVEL`	`TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR` or `OFF`	`camel.main.log-level`
`--console`	start the management server with the developer console, health checks and metrics	`camel.server.enabled`, `devConsoleEnabled`, `healthCheckEnabled`, `metricsEnabled` = `true`
`--port N`	the HTTP port for REST, `platform-http` and the management server (default 8080)	`camel.server.port`
`--trace`	trace every message through the routes	`camel.main.tracing=true`
`--mcp`	serve `ai-tool` routes as an MCP server over Streamable HTTP at `/mcp`	`camel.server.mcp-enabled=true`
`--mcp-stdio`	serve them over standard input and output (for Claude Desktop and other local clients); not with `--background`	`camel.server.mcp-transport=stdio`
`--mcp-expose PATTERNS`	serve existing routes as MCP tools without editing them: `rest:`, `rest:/orders`, `direct:lookup-`, `route:billing-`, comma separated; turns on the MCP server (HTTP, or stdio with `--mcp-stdio`)	`camel.server.mcp-expose-routes`

--mcp and --mcp-stdio expose every tool (camel.server.mcp-tags=*,untagged) unless you set camel.server.mcp-tags yourself. With --mcp-expose, REST operations become tools with typed arguments, GET and HEAD are read-only and every other exposed tool needs approval (Expose existing routes). A --prop given on the command line wins over the flags above and over every file. The full order and every key are in Configuration.

cameleer run orders.camel.yaml --profile prod --port 9090
cameleer run --dev                                  # every route file here, reloaded on change
cameleer run job.camel.yaml --max-messages 1        # a run-once job
cameleer run tools.camel.yaml --mcp-stdio           # an MCP server for a desktop client
cameleer run orders.camel.yaml --mcp-expose rest:*  # its REST API as MCP tools, no route edits
docker run --rm -p 8080:8080 -v "$PWD:/routes:ro" pmsudhi/cameleer run /routes/orders.camel.yaml --console

Each running integration writes status and log files to $CAMEL_HOME (default ~/.camel); the management commands below read them. Set CAMEL_LOCAL_STATUS=false to turn this off. The Docker image does, and so do AWS Lambda, Cloud Run, Knative and Azure Functions, where one process runs per instance and logs go to standard output. When the binary is named bootstrap and started without arguments, it runs as an AWS Lambda custom runtime.

cameleer init

text

cameleer init <file> [--directory DIR]

Writes a starter file chosen by the file name, and refuses to overwrite an existing one:

file name	what it writes
`.yaml`, `.yml`	a YAML route with a timer and a log
`*.xml`	an XML route
`*.kamelet.yaml`	a source Kamelet with two parameters
`*.pipe.yaml`	a Pipe from `timer-source` to `log-sink`
`*.integration.yaml`	a Camel K `Integration` with a property
`*.properties`	an `application.properties` skeleton

--directory writes into that folder, creating it if needed.

cameleer validate

text

cameleer validate <file-or-dir>... [--format text|json] [--strict] [--properties FILE] [--prop key=value]

Checks route files without starting anything: YAML and XML syntax, the DSL structure, endpoint URIs and their options, expressions, unresolved placeholders, dangling direct: endpoints and duplicate route ids. Exit code 0 means valid, 1 means errors (or warnings with --strict), 2 a usage error. --format json prints a machine-readable report for coding agents and CI. --properties (repeatable) and --prop supply the values placeholders resolve to; without --properties the application.* files of the current directory are read. The codes and the report format are in Validate route files.

cameleer schema

text

cameleer schema

Prints the JSON Schema of the YAML DSL to standard output, for editors and coding agents. See YAML DSL.

cameleer test

text

cameleer test <test-file>...

Runs YAML test files (*.test.yaml): each loads routes, sends messages, and checks bodies, headers, mock endpoints and, for agent routes, recorded model responses replayed without a model. Fails when a test fails. cameleer run and cameleer validate skip test files. See the agent step for an example.

cameleer export

text

cameleer export [files...] --directory DIR [--name N] [--camel-path PATH]

Writes a standalone Cargo project to DIR: the route and application.* files are copied to resources/ and compiled into the binary, and an application.properties next to the binary at run time overrides the embedded one. Without files it exports every .yaml, .yml, .xml and .properties file of the current directory; with files, the application.* files of the current directory are added. --name names the package (default: the first route file's name).

The generated Cargo.toml depends on cameleer-main by path: --camel-path is the folder that holds the cameleer-main crate, and it defaults to the source tree the CLI was built from. With the Docker image or a cargo install build, pass --camel-path to the crates folder of a clone of the repository, or replace the line with the published crate (cameleer-main = "0.5").

cameleer bind

text

cameleer bind <name> --source S --sink S [--step S]... [--property target.key=value]...
              [--error-handler log|none|sink:URI] [--output FILE]

Writes a Camel Pipe resource that binds a source to a sink. S is a Kamelet name (timer-source, or kamelet:timer-source) or an endpoint URI (log:out). --step adds steps in order. --property sets a Kamelet property on source., sink. or step-N. (from 0): --property source.message=hi. --error-handler adds a log, none or sink:<uri or kamelet> error handler. The file is <name>.yaml unless --output says otherwise; run it with cameleer run.

cameleer bind ticker --source timer-source --sink log-sink --property source.message=hi
cameleer run ticker.yaml

cameleer catalog

text

cameleer catalog [components|languages|kamelets]

Lists the component schemes (the default), expression languages or bundled Kamelets in this binary, one per line. A build with fewer cargo features lists fewer (Build features). Each component's options are on its reference page, docs/components/<scheme>.md.

Managing running integrations

These commands act on integrations started with cameleer run on the same machine, through the status files in $CAMEL_HOME. [name|pid] selects one by its name (wildcards such as ord* work) or process id; it can be left out when only one integration is running.

command	what it does
`cameleer ps`	a table of running integrations: PID, name, age, routes, total and failed messages
`cameleer stop [name\|pid]`	stop one gracefully; `--all` stops every one
`cameleer get routes [name]`	a table of routes with their state and statistics
`cameleer get context\|health\|endpoints [name]`	the context, health checks or endpoints as JSON; `get health` exits with 1 when the status is DOWN
`cameleer get ... --url URL`	ask a management server over HTTP instead (`/q/dev/*`, `/q/health`), for example in a container or on another host
`cameleer cmd ACTION [name] [--id ROUTE]`	`start-route`, `stop-route`, `suspend-route`, `resume-route`, `reset-stats` or `reload`; `--id` names a route, every route by default
`cameleer log [name] [--tail N] [--follow]`	print the log, the last N lines, and keep printing new lines until the integration stops
`cameleer trace [name]`	turn tracing on, or print the traced messages when it is on; `--disable` turns it off

cameleer run orders.camel.yaml --background
cameleer ps
cameleer get routes orders
cameleer cmd suspend-route orders --id ingest
cameleer log orders --tail 20
cameleer stop orders
cameleer get health --url http://localhost:8080      # a container started with --console

cameleer tool

text

cameleer tool list|approvals [name|pid] [--json]
cameleer tool disable|enable <tool> [name|pid]
cameleer tool approve <handle> [--by NAME] [name|pid]
cameleer tool deny <handle> [--by NAME] [--reason TEXT] [name|pid]

Operates the AI tools of a running integration. list shows each tool and whether it is enabled. disable is a kill switch: the tool refuses calls at once, without a restart, until enable. approvals lists calls waiting for a person, and approve or deny decides one by its handle; --by records who decided (default: the user name) and --reason why. --json prints machine-readable output. These commands need a build with the ai feature (every default build has it). See MCP server.

Environment variables the CLI reads

variable	what it does
`CAMEL_*`	configuration keys: `CAMEL_SERVER_PORT=9090` is `camel.server.port=9090` (Configuration)
`CAMEL_LOG_LEVEL`	the log level, `INFO` by default
`CAMEL_HOME`	where status and log files go, `~/.camel` by default
`CAMEL_LOCAL_STATUS`	`false` turns status and log files off
`SSL_CERT_FILE`	a PEM bundle of trusted CA certificates (needed on Windows, see the FAQ)

A worked example

This sequence runs in the test suite (cli_guide_worked_example in crates/cameleer-main/tests/docs_reference.rs): it writes a starter route, validates it, and runs it as a job that stops after two messages.

cameleer init hello.camel.yaml
cameleer validate hello.camel.yaml
cameleer run hello.camel.yaml --max-messages 2

init prints Created ./hello.camel.yaml, validate exits with 0, and run logs Hello Camel from route1 twice (the timer fires once a second) and exits with 0.

Common questions

How do I run every route file in a folder?

Run cameleer run in that folder without file names. It skips application* files and *.test.yaml files.

How do I run a route once and exit?

Give it a limit: --max-messages 1 stops after one message, --max-seconds N after N seconds and --max-idle-seconds N when nothing has happened for N seconds. A timer with repeatCount plus --max-idle-seconds ends a batch job.

How do I see what a running integration is doing?

cameleer ps lists it, cameleer get routes shows each route's message counts, cameleer log --follow prints its log and cameleer trace prints each message as it moves through the routes. In a container, start it with --console and use cameleer get ... --url.

Where is `camel run`?

Cameleer's command is cameleer, not camel, so it does not clash with Apache Camel's Camel JBang. The subcommands have the same names.

How do I list a component's options?

cameleer catalog components lists the schemes; the options of each are on its page under components, with the same names as in Apache Camel.

Getting started, Configuration, Validate route files
Deployment: Docker, Kubernetes, Cloud Run, AWS Lambda
MCP server for --mcp and cameleer tool

Found a problem?

If something on this page doesn't match what Cameleer does, or you hit a bug while building with it, please help fix it, whether you are a person or a coding agent: open an issue that describes what you saw, then fork the repository, fix it, add or update a test, run cargo test --workspace, and open a pull request. CONTRIBUTING.md explains the ground rules.

The cameleer command line: every command and flag

Commands at a glance

cameleer run

cameleer init

cameleer validate

cameleer schema

cameleer test

cameleer export

cameleer bind

cameleer catalog

Managing running integrations

cameleer tool

Environment variables the CLI reads

A worked example

Common questions

How do I run every route file in a folder?

How do I run a route once and exit?

How do I see what a running integration is doing?

Where is camel run?

How do I list a component's options?

Related

Found a problem?

Where is `camel run`?