From 5064f02df0efc76025936d90b51951e10692f5c5 Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Thu, 12 Nov 2026 20:42:10 +0100 Subject: [PATCH 01/11] Blog: the Camel CLI in Camel 4.24 - fast, on aesh, and an AI can trust it Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 200 ++++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 content/blog/2026/11/camel-cli-424/index.md diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md new file mode 100644 index 00000000000..549c1dd3485 --- /dev/null +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -0,0 +1,200 @@ +--- +title: "The Camel CLI in Camel 4.24: starts in a blink, now on aesh" +date: 2026-11-17 +draft: false +authors: [davsclaus] +categories: ["Camel", "Tooling"] +keywords: ["apache camel", "camel cli", "camel 4.24", "aesh", "picocli", "startup", "class data sharing", "exit codes", "ai agents", "self-update"] +preview: "The Camel CLI in Camel 4.24 runs a command in about 150 ms, where 4.23 took more than a second. It parses its command lines with aesh instead of picocli, and it is a CLI an AI agent can trust and keep up with: documented exit codes, errors on stderr, JSON output and timeouts." +--- + +You type `camel` many times a day: `camel run`, `camel ps`, `camel get route`, `camel log`. And now so do AI agents, +which call the CLI over and over in a loop. In Camel 4.24 the Camel CLI got a lot of attention. This post is about +three changes: + +* it is fast: a command such as `camel version` or `camel ps` takes about 150 ms, where 4.23 took more than a second +* it runs on [aesh](https://github.com/aeshell/aesh) instead of picocli +* it is a CLI an AI agent can trust: exit codes, errors on stderr, JSON output and timeouts + +And then some of the smaller things that make the day better. + +## Fast + +This is the time a command takes, from typing it to the prompt coming back. It is the median of 15 runs of the +`camel` launcher of the distribution (4.23.0, and a nightly build of 4.24), on an Apple M4 Pro with Java 25: + +| Command | Camel 4.23 | Camel 4.24 | +|--------------------|-----------:|-----------:| +| `camel version` | 1251 ms | 146 ms | +| `camel ps` | 1292 ms | 188 ms | +| `camel init --help`| 1234 ms | 149 ms | +| `camel get --help` | 1232 ms | 179 ms | +| `camel run --help` | 1239 ms | 326 ms | +| `camel --help` | 1242 ms | 329 ms | + +That is about 8 times faster for the commands you use the most. A `camel ps` now comes back before you notice it +was gone. For you that is nice. For an AI agent it matters much more, as we will see below. + +Where did the second go? Not into one big fix, but many small ones, found by measuring first: + +* **Only the command you run is created.** The Camel CLI has more than 160 commands. Camel 4.23 created all of them, + with all their options, and those of every plugin, before it ran one. Now `camel ps` creates `camel ps`, and a + plugin command creates only that plugin. +* **No logging unless something logs.** Most commands log nothing, yet log4j was started for each of them. Also the + check for a newer version of the CLI started log4j, before every command. +* **The launcher script no longer runs `java -version`** to find out the Java version. It reads the release file of + the JDK instead, which saves starting a second JVM. +* **The JVM no longer waits at exit** for the thread of an HTTP client that a command created but never used, or + for the update check. +* **The distribution runs from plain jars.** Camel 4.23 ran the CLI from one Spring Boot fat jar, which has its own + class loader for the nested jars. Camel 4.24 has the jars in `lib/`, next to a thin launcher jar. +* **Class data sharing.** Because the jars are plain jars now, the JVM can keep the classes a command loads in an + archive, and map it in on the next run. The `camel` script does this by itself: the first run of a command writes + the archive (under `~/.cache/camel-cli/cds/`), and the runs after it are faster. Set `CAMEL_CDS=false` to turn it + off. Without the archive, `camel version` takes 186 ms instead of 146 ms, and `camel --help` 559 ms instead of + 329 ms. +* **aesh.** More about that below. + +## On aesh instead of picocli + +The Camel CLI has used [picocli](https://picocli.info/) from its start. picocli served us well, but it moves slowly +now: its last release was in April 2025. In Camel 4.24 the Camel CLI parses its command lines, prints its help and +completes its commands with [aesh](https://github.com/aeshell/aesh), the Java library for command line tools by +Ståle Pedersen. + +The main reason for the move is not speed. It is that aesh is a living project, with a maintainer we can talk to. We +saw that during the port. Before switching, we ported all of the CLI on a branch and wrote down every gap and bug we +found in aesh: 36 issues and 17 pull requests. Ståle fixed or merged nearly all of them within days, and released aesh +3.19 and 3.19.1 with them. Thank you, Ståle! + +aesh is a little faster too. In our measurements during the port, aesh took about 20 ms off `camel version`, and +about 60 ms off `camel --help`. That is a small part of the second above, but it all adds up. + +### What changes for you + +For using the Camel CLI, not much. The commands and their options are the same. To be sure of that, before the +switch we wrote a test with 2207 command lines and what picocli made of them, and one with the help of all commands +and the errors of wrong command lines. The aesh port had to give the same answers. + +The help looks a little different: the default value of an option is on a line of its own (`Default: ...`). + +An argument `@file` is replaced by the arguments in that file, as it was with picocli, such as `camel @run.txt`. + +If you wrote your own plugin for the Camel CLI, it must be changed and built for Camel 4.24: a plugin adds its +commands to a `CommandTree` instead of a picocli `CommandLine`, and the commands use the aesh annotations. The +[upgrade guide](/manual/camel-4x-upgrade-guide-4_24.html) has the details. + +## A CLI that an AI can trust, and that keeps up with it + +More and more, the Camel CLI is not called by a person, but by an AI agent. The agent works in a loop: it runs a +command, reads what came back, decides the next step, and runs the next command. To build and fix an integration it +looks up a component, writes a route, validates it, runs it, reads the log, sends a message, checks the routes, and +goes around again. That is easily 50 or 100 calls of the CLI for one task. + +### Fast matters more for an AI than for you + +When you type a command, one second is a short pause. You were reading the last output anyway. For an agent, every +call is a stop: the loop waits for the CLI before the model can think about the next step. 100 calls of a CLI that +takes 1.25 seconds is more than two minutes of waiting. At 150 ms it is 15 seconds. + +And it is not only about time. When a check is cheap, an agent does it: it looks up the option instead of guessing +it, it validates after each change, and it checks the routes once more after the reload. When every call costs a +second, there are fewer of those checks for the same time and the same budget, and more guessing. A fast CLI makes the +agent quicker, and it makes it better, because it can afford to verify. Running a local model, where the model is +already the slow part, you want every other part of the loop to be as fast as possible. + +### An answer an AI can trust + +An agent cannot see your screen. All it has is the exit code and the text that came back, and it builds its next +step on that. A person reads "ERROR: no integration found" and knows what to do, even when the exit code says `0`. An +agent that gets `0` for a command that did not work takes it as a fact, and goes down the wrong path. A command that +waits for a terminal that is not there leaves the agent stuck until its own timeout. Every answer the CLI gets wrong +costs the agent more than the command took. + +So in Camel 4.24 the Camel CLI has a contract: the +[exit codes and output](/manual/camel-jbang-exit-codes.html). The same contract is good for a script and a CI job too: + +| Exit code | Meaning | +|----------:|----------------------------------------------------------------| +| 0 | success | +| 1 | the command failed | +| 2 | usage error: a wrong option or argument | +| 3 | not found: no integration, route, Kamelet or plugin of that name | +| 66 | a file or directory that does not exist | +| 70 | internal error | +| 124 | timed out: the integration did not answer in time | + +And with it: + +* Errors go to stderr, so the output on stdout can be read as is. +* With `--json`, stdout is exactly one JSON document, also when the command fails, so it can always be parsed. A + listing with nothing in it prints `[]`. +* Commands that talk to a running integration take a `--timeout`, and say so when the integration did not answer, + instead of waiting forever. +* No command waits for a terminal that is not there. Without one, `--watch` shows the output once, `camel log` does + not follow, and a command that needs a terminal, such as `camel debug`, exits with `2` instead of hanging a CI job. +* `camel stop` and `camel restart` wait until the integration has stopped, and exit with `124` when it did not stop + in time. +* `camel run --background` waits for the integration to start, and a file that does not exist fails before anything + starts. + +The AI tools of the Camel CLI, the [MCP server](/manual/camel-jbang-mcp.html) and `camel ask`, pass these failures on +to the agent as errors, so the model sees what went wrong instead of guessing it. + +Fast and trustworthy go together: the agent calls the CLI often because each call is cheap, and it can act on what +comes back because the answer is right. + +## Stay up to date + +The [web installer](/manual/camel-jbang-launcher-install.html) installs the latest release: + +```shell +curl -fsSL https://camel.apache.org/install.sh | sh +``` + +You can ask it for the newest LTS release, or the newest release of a line, and `camel self-update` stays on it: + +```shell +curl -fsSL https://camel.apache.org/install.sh | sh -s -- --version LTS +curl -fsSL https://camel.apache.org/install.sh | sh -s -- --version 4.24 +``` + +And new in 4.24: try what is coming before it is released. Apache publishes a nightly build of the Camel CLI, and +`camel self-update` can switch to it, and back: + +```shell +camel self-update --version SNAPSHOT +``` + +Nightly builds are development builds for testing, not Apache releases. + +## The smaller things + +* `camel cmd send` can feed a route: `--repeat` and `--interval` send many messages, and `--body=file:` sends the + files of a folder, one message per file. + + ```shell + camel cmd send --endpoint=kafka:refunds --body=file:refund.json --repeat=50 --interval=100..500 + ``` + +* `camel run --data-dir` names the folders with data files under the source directory, which dev mode does not watch, + so writing a file there does not reload the routes. +* In dev mode, a reload applies changed `camel.beans` and `camel.component` properties, and a dependency added to + `camel.jbang.dependencies` while the app runs is downloaded. +* The log of the previous run is kept, also for the Spring Boot and Quarkus runtimes, so you can read why it failed + at startup. `camel dirty --clean` removes those logs too. +* `camel cmd route-diagram`, `route-structure` and `route-topology` read Java routes with the Java DSL parser, without + compiling them. + +## Try it + +Try it now with the nightly build: + +```shell +camel self-update --version SNAPSHOT +``` + +When Camel 4.24 is released, `camel self-update --version 4.24` switches back to the releases. Or install it with the +web installer above. + +And then type `camel ps`, and see how fast it comes back. From 983a70fe553586ae08d83f8a36387a87bce3e4f3 Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Sat, 14 Nov 2026 12:25:31 +0100 Subject: [PATCH 02/11] Blog: the Camel CLI in Camel 4.24 - keeping up with an agent, and the fixes of the CLI scan Adds what the CAMEL-26935 work made faster for an agent (action round trip, background readiness, camel cmd reload --wait --json, camel status --json), and the fixes of the CLI scan (CAMEL-26929 to CAMEL-26934) that matter to users and agents. Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 46 ++++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index 549c1dd3485..e4d18bf68c6 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -137,9 +137,42 @@ And with it: in time. * `camel run --background` waits for the integration to start, and a file that does not exist fails before anything starts. +* A route that fails to start exits with `1`, which says "fix the route", with one line on stderr: the stack trace + is in the log already. Before, it was `70`, which says "a bug in Camel, do not retry", so an agent gave up instead of + fixing its route. +* With `orders` and `orders-v2` running, `camel stop orders` stops `orders`. A name was a prefix only, so it stopped + both, and every command for one integration failed for `orders`. A name that no integration has is still a prefix. +* An option given on the command line wins over `application.properties`. With `camel.main.tracing=false` in the + file, `camel run --trace` printed no trace. +* No ANSI color codes when the output is a file or a pipe, unless `--logging-color` is given: `camel cmd send + --reply | cat` had them. +* `camel validate` exits with `66` for a file that does not exist, and for nothing to validate. It said "Validation + success (files:0)" for a `notes.txt`. The AI tools of the Camel CLI, the [MCP server](/manual/camel-jbang-mcp.html) and `camel ask`, pass these failures on -to the agent as errors, so the model sees what went wrong instead of guessing it. +to the agent as errors, so the model sees what went wrong instead of guessing it. And they act on the integration the +agent named: a runtime tool takes the integration as `nameOrPid`, `name` or `pid`, where a `name` was ignored and the +tool acted on the only integration that ran, which could be another app. `camel_get_files` reads a large file in parts, +instead of an answer of a million tokens, and `camel_edit_file` keeps a `replace` of only whitespace, which matters in +YAML. + +### Keeping up with the agent + +An agent does not only start commands, it talks to the integration it is building: it sends a message, reloads a +changed route, and asks how the integration is doing. In Camel 4.24 those got faster, and some of them got a command +of their own: + +* **An action is answered in about 25 ms**, such as `camel cmd send` or `camel get route`, where it took about 110 ms. + The CLI and the integration looked for each other's files every 100 ms; now they look much more often, but only + read the folder when it changed. +* **`camel run --background` returns when the routes are up**, about 0.4 s after Camel started, where it was about + 1.3 s. The integration writes its status at once when it has started, instead of on the next tick of a second. +* **`camel cmd reload --wait --json`** reloads the changed files of an integration in dev mode at once, and says how it + went: `reloaded`, `unchanged` or `failed`, with the error. Before, an agent wrote a file and then had to guess when + the reload had happened. +* **`camel status --json`** is the state of an integration in one call: its routes, the problems first, the + last errors and log lines, the HTTP endpoints, and the oldest exchange in flight. In about 0.3 s, where `camel get + route`, `get health`, `get error` and `camel log` took about a second together. Fast and trustworthy go together: the agent calls the CLI often because each call is cheap, and it can act on what comes back because the answer is right. @@ -185,6 +218,17 @@ Nightly builds are development builds for testing, not Apache releases. at startup. `camel dirty --clean` removes those logs too. * `camel cmd route-diagram`, `route-structure` and `route-topology` read Java routes with the Java DSL parser, without compiling them. +* `camel cmd send --body=...` without a name sends to the integration that runs, such as after `camel run --stub=jms`. + It sent to an empty Camel of its own, and said "Sent (success)". An endpoint of a system outside the integrations, + such as `kafka:topic`, is still sent from the CLI. +* A `camel-cli.properties` in the current directory is laid over the global `~/.camel-cli.properties`, rather than + hiding all of it. +* From the launcher, `camel export` exports the Citrus tests, `--jvm-debug` and `--jvm-args` work without JBang, + and `camel.bat` has Windows line endings. +* `camel kubernetes` honours `--kube-config` in all commands, and `camel kubernetes logs` stops at a pod that has + finished. +* `camel generate rest --routes` writes routes that validate and run, with a log step to replace, and `camel test init` + does not overwrite a test you edited, unless `--force`. ## Try it From 310ebf596dd01c72429c9a7a82bb65e6bc05e9b6 Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Sat, 14 Nov 2026 13:26:42 +0100 Subject: [PATCH 03/11] Blog: the Camel CLI in Camel 4.24 - eval, send timeout, JSON rows, dev reload and the smaller fixes of the CLI scan Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index e4d18bf68c6..313596578bf 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -148,6 +148,14 @@ And with it: --reply | cat` had them. * `camel validate` exits with `66` for a file that does not exist, and for nothing to validate. It said "Validation success (files:0)" for a `notes.txt`. +* `X=$(camel eval expression ...)` is only the value. The Camel that `camel eval` starts for itself printed its state + first. +* The `--timeout` of `camel cmd send` bounds the send, not only the wait of the CLI. A send to `direct:nope` waited + 30 seconds for a consumer and ended in a timeout of the CLI; now it fails at once with "No consumers available". +* Options do with `--json` what they do without: `camel cmd route-structure --json --filter=orders` printed every + route, and a filter that matches nothing exits with `3`. `camel cmd receive --output=json` has only JSON on stdout. +* A row of a JSON listing says which integration it is of, with `pid` as a number and `name`, and a list is a list + also for one integration. The AI tools of the Camel CLI, the [MCP server](/manual/camel-jbang-mcp.html) and `camel ask`, pass these failures on to the agent as errors, so the model sees what went wrong instead of guessing it. And they act on the integration the @@ -211,7 +219,8 @@ Nightly builds are development builds for testing, not Apache releases. ``` * `camel run --data-dir` names the folders with data files under the source directory, which dev mode does not watch, - so writing a file there does not reload the routes. + so writing a file there does not reload the routes. Nor do the files a run writes itself: `camel dev > run.log` + reloaded the routes every 2 seconds. Log files, `target`, `.git` and the `.camel` folders are not watched. * In dev mode, a reload applies changed `camel.beans` and `camel.component` properties, and a dependency added to `camel.jbang.dependencies` while the app runs is downloaded. * The log of the previous run is kept, also for the Spring Boot and Quarkus runtimes, so you can read why it failed @@ -226,7 +235,15 @@ Nightly builds are development builds for testing, not Apache releases. * From the launcher, `camel export` exports the Citrus tests, `--jvm-debug` and `--jvm-args` work without JBang, and `camel.bat` has Windows line endings. * `camel kubernetes` honours `--kube-config` in all commands, and `camel kubernetes logs` stops at a pod that has - finished. + finished. `camel kubernetes export` puts `--env`, `--config`, `--volume`, `--label` and `--annotation` in a CronJob + and a Knative Service too, where they were dropped without a word. +* `camel debug --breakpoint tick` and `--source-dir` work; the debug options were taken apart wrongly before they went + to `camel run`. +* `camel init` gives a Kamelet its kind from the file name, puts `./x.yaml` in `--dir`, and refuses a Java file whose + name is not a class name, such as `my-route.java`. +* `camel doctor` checks a nightly build against the Apache snapshots, where it reported Maven as failed. +* `camel cmd logger --logging-level=BOGUS` is a usage error instead of setting the level to `ERROR`, and + `camel cmd browse --endpoint=seda:foo`, the example of its own help, finds `seda://foo`. * `camel generate rest --routes` writes routes that validate and run, with a log step to replace, and `camel test init` does not overwrite a test you edited, unless `--force`. From 53378542a4c1afdf14d956556cb16e457e9531cf Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Sat, 14 Nov 2026 13:48:41 +0100 Subject: [PATCH 04/11] Blog: the Camel CLI in Camel 4.24 - missing files, source lines in the AI tools, catalog typos, infra stop Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index 313596578bf..f1663840aa6 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -147,7 +147,8 @@ And with it: * No ANSI color codes when the output is a file or a pipe, unless `--logging-color` is given: `camel cmd send --reply | cat` had them. * `camel validate` exits with `66` for a file that does not exist, and for nothing to validate. It said "Validation - success (files:0)" for a `notes.txt`. + success (files:0)" for a `notes.txt`. So do `camel export`, `camel dependency` and `camel transform route` for a + file that does not exist, with the message on stderr. * `X=$(camel eval expression ...)` is only the value. The Camel that `camel eval` starts for itself printed its state first. * The `--timeout` of `camel cmd send` bounds the send, not only the wait of the CLI. A send to `direct:nope` waited @@ -162,7 +163,8 @@ to the agent as errors, so the model sees what went wrong instead of guessing it agent named: a runtime tool takes the integration as `nameOrPid`, `name` or `pid`, where a `name` was ignored and the tool acted on the only integration that ran, which could be another app. `camel_get_files` reads a large file in parts, instead of an answer of a million tokens, and `camel_edit_file` keeps a `replace` of only whitespace, which matters in -YAML. +YAML. The lines of source code in the answers are as they are in the file, without `\"`, and a misspelled name in the +catalog, such as `kafak`, suggests `kafka`. ### Keeping up with the agent @@ -242,6 +244,7 @@ Nightly builds are development builds for testing, not Apache releases. * `camel init` gives a Kamelet its kind from the file name, puts `./x.yaml` in `--dir`, and refuses a Java file whose name is not a class name, such as `my-route.java`. * `camel doctor` checks a nightly build against the Apache snapshots, where it reported Maven as failed. +* `camel infra stop --kill` no longer kills a process that got the pid of a service that was killed hard. * `camel cmd logger --logging-level=BOGUS` is a usage error instead of setting the level to `ERROR`, and `camel cmd browse --endpoint=seda:foo`, the example of its own help, finds `seda://foo`. * `camel generate rest --routes` writes routes that validate and run, with a log step to replace, and `camel test init` From f731fe6b13702858a1f98fd26432c69574d12fba Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Sat, 14 Nov 2026 19:09:46 +0100 Subject: [PATCH 05/11] Blog: Camel CLI 4.24 - a Camel version that does not exist, dev mode reload of properties and two folders, --exclude Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index f1663840aa6..bc30bc1de4e 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -149,6 +149,10 @@ And with it: * `camel validate` exits with `66` for a file that does not exist, and for nothing to validate. It said "Validation success (files:0)" for a `notes.txt`. So do `camel export`, `camel dependency` and `camel transform route` for a file that does not exist, with the message on stderr. +* A `--camel-version` that was never released says `Camel version 9.9.9 not found` and exits with `3`, in `camel + catalog`, `camel doc` and `camel validate`. It said "Cannot resolve dependencies", which reads like a network + problem, and that still exits with `1`. `camel version set 9.9.9` refuses it, where it stored it for every later + command to fail on. * `X=$(camel eval expression ...)` is only the value. The Camel that `camel eval` starts for itself printed its state first. * The `--timeout` of `camel cmd send` bounds the send, not only the wait of the CLI. A send to `direct:nope` waited @@ -223,6 +227,10 @@ Nightly builds are development builds for testing, not Apache releases. * `camel run --data-dir` names the folders with data files under the source directory, which dev mode does not watch, so writing a file there does not reload the routes. Nor do the files a run writes itself: `camel dev > run.log` reloaded the routes every 2 seconds. Log files, `target`, `.git` and the `.camel` folders are not watched. +* In dev mode, a change of `application.properties` is reloaded, and with files in two folders, such as + `camel run a.camel.yaml other/b.camel.yaml --dev`, both are watched: only the folder of `b.camel.yaml` was. +* `--exclude` takes a folder, such as `--exclude=sub/**`, and works for `camel run .`, `--source-dir` and `camel dev`, + where it was left out. * In dev mode, a reload applies changed `camel.beans` and `camel.component` properties, and a dependency added to `camel.jbang.dependencies` while the app runs is downloaded. * The log of the previous run is kept, also for the Spring Boot and Quarkus runtimes, so you can read why it failed From 22082301305d00acb2342d58d424073fa9d38288 Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Sat, 14 Nov 2026 19:55:31 +0100 Subject: [PATCH 06/11] Blog: Camel CLI 4.24 - repeated catalog miss, camel run '*', config value errors Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index bc30bc1de4e..188ab9dde6d 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -168,7 +168,8 @@ agent named: a runtime tool takes the integration as `nameOrPid`, `name` or `pid tool acted on the only integration that ran, which could be another app. `camel_get_files` reads a large file in parts, instead of an answer of a million tokens, and `camel_edit_file` keeps a `replace` of only whitespace, which matters in YAML. The lines of source code in the answers are as they are in the file, without `\"`, and a misspelled name in the -catalog, such as `kafak`, suggests `kafka`. +catalog, such as `kafak`, suggests `kafka`, and asking for it a third time says so again, rather than to go on with +the options the answer gave. ### Keeping up with the agent @@ -229,6 +230,11 @@ Nightly builds are development builds for testing, not Apache releases. reloaded the routes every 2 seconds. Log files, `target`, `.git` and the `.camel` folders are not watched. * In dev mode, a change of `application.properties` is reloaded, and with files in two folders, such as `camel run a.camel.yaml other/b.camel.yaml --dev`, both are watched: only the folder of `b.camel.yaml` was. +* `camel run '*'` works when the shell does not expand the `*`, such as the Windows command prompt: it said "No + routes found in: *". +* A value in the configuration that an option does not take, such as `runtime=springboot`, says which file, key and + value; every command with `--runtime` failed with "DefaultValueProvider failed for option runtime". `camel config + set` refuses such a value, and `camel config unset` of a key that is not set exits with `3`. * `--exclude` takes a folder, such as `--exclude=sub/**`, and works for `camel run .`, `--source-dir` and `camel dev`, where it was left out. * In dev mode, a reload applies changed `camel.beans` and `camel.component` properties, and a dependency added to From 39d0019fc91402b94a73db3327f4a2f9ba4a2ef6 Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Sun, 15 Nov 2026 20:39:42 +0100 Subject: [PATCH 07/11] Blog: Camel CLI 4.24 - new numbers from main, camel stop --all, the MCP and AI tool fixes, and the fixes of the rest of the CLI scan Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 85 ++++++++++++++++----- 1 file changed, 66 insertions(+), 19 deletions(-) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index 188ab9dde6d..8f489bafdad 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -5,14 +5,14 @@ draft: false authors: [davsclaus] categories: ["Camel", "Tooling"] keywords: ["apache camel", "camel cli", "camel 4.24", "aesh", "picocli", "startup", "class data sharing", "exit codes", "ai agents", "self-update"] -preview: "The Camel CLI in Camel 4.24 runs a command in about 150 ms, where 4.23 took more than a second. It parses its command lines with aesh instead of picocli, and it is a CLI an AI agent can trust and keep up with: documented exit codes, errors on stderr, JSON output and timeouts." +preview: "The Camel CLI in Camel 4.24 runs a command in about 125 ms, where 4.23 took more than a second. It parses its command lines with aesh instead of picocli, and it is a CLI an AI agent can trust and keep up with: documented exit codes, errors on stderr, JSON output and timeouts." --- You type `camel` many times a day: `camel run`, `camel ps`, `camel get route`, `camel log`. And now so do AI agents, which call the CLI over and over in a loop. In Camel 4.24 the Camel CLI got a lot of attention. This post is about three changes: -* it is fast: a command such as `camel version` or `camel ps` takes about 150 ms, where 4.23 took more than a second +* it is fast: a command such as `camel version` or `camel ps` takes about 125 ms, where 4.23 took more than a second * it runs on [aesh](https://github.com/aeshell/aesh) instead of picocli * it is a CLI an AI agent can trust: exit codes, errors on stderr, JSON output and timeouts @@ -21,18 +21,19 @@ And then some of the smaller things that make the day better. ## Fast This is the time a command takes, from typing it to the prompt coming back. It is the median of 15 runs of the -`camel` launcher of the distribution (4.23.0, and a nightly build of 4.24), on an Apple M4 Pro with Java 25: +`camel` launcher of the distribution (4.23.0, and 4.24 built from main), after 3 runs to warm up, on an Apple M4 Pro +with Java 25: | Command | Camel 4.23 | Camel 4.24 | |--------------------|-----------:|-----------:| -| `camel version` | 1251 ms | 146 ms | -| `camel ps` | 1292 ms | 188 ms | -| `camel init --help`| 1234 ms | 149 ms | -| `camel get --help` | 1232 ms | 179 ms | -| `camel run --help` | 1239 ms | 326 ms | -| `camel --help` | 1242 ms | 329 ms | - -That is about 8 times faster for the commands you use the most. A `camel ps` now comes back before you notice it +| `camel version` | 1233 ms | 128 ms | +| `camel ps` | 1223 ms | 122 ms | +| `camel init --help`| 1196 ms | 138 ms | +| `camel get --help` | 1182 ms | 167 ms | +| `camel run --help` | 1202 ms | 256 ms | +| `camel --help` | 1198 ms | 256 ms | + +That is about 10 times faster for the commands you use the most. A `camel ps` now comes back before you notice it was gone. For you that is nice. For an AI agent it matters much more, as we will see below. Where did the second go? Not into one big fix, but many small ones, found by measuring first: @@ -41,7 +42,11 @@ Where did the second go? Not into one big fix, but many small ones, found by mea with all their options, and those of every plugin, before it ran one. Now `camel ps` creates `camel ps`, and a plugin command creates only that plugin. * **No logging unless something logs.** Most commands log nothing, yet log4j was started for each of them. Also the - check for a newer version of the CLI started log4j, before every command. + check for a newer version of the CLI started log4j, before every command. And a Camel class that only has a logger + no longer starts it either. `camel ps` loads 1,591 classes, and none of log4j or Jackson. In 4.23 it loaded 5,373, + of which 704 were of log4j. +* **No terminal when there is none.** A command whose output goes to a file or a pipe built a terminal only to find + out that there was none, to leave out the colors. * **The launcher script no longer runs `java -version`** to find out the Java version. It reads the release file of the JDK instead, which saves starting a second JVM. * **The JVM no longer waits at exit** for the thread of an HTTP client that a command created but never used, or @@ -51,8 +56,8 @@ Where did the second go? Not into one big fix, but many small ones, found by mea * **Class data sharing.** Because the jars are plain jars now, the JVM can keep the classes a command loads in an archive, and map it in on the next run. The `camel` script does this by itself: the first run of a command writes the archive (under `~/.cache/camel-cli/cds/`), and the runs after it are faster. Set `CAMEL_CDS=false` to turn it - off. Without the archive, `camel version` takes 186 ms instead of 146 ms, and `camel --help` 559 ms instead of - 329 ms. + off. Without the archive, `camel version` takes 154 ms instead of 128 ms, and `camel --help` 411 ms instead of + 256 ms. * **aesh.** More about that below. ## On aesh instead of picocli @@ -95,7 +100,7 @@ goes around again. That is easily 50 or 100 calls of the CLI for one task. When you type a command, one second is a short pause. You were reading the last output anyway. For an agent, every call is a stop: the loop waits for the CLI before the model can think about the next step. 100 calls of a CLI that -takes 1.25 seconds is more than two minutes of waiting. At 150 ms it is 15 seconds. +takes 1.2 seconds is two minutes of waiting. At 125 ms it is less than 13 seconds. And it is not only about time. When a check is cheap, an agent does it: it looks up the option instead of guessing it, it validates after each change, and it checks the routes once more after the reload. When every call costs a @@ -135,6 +140,11 @@ And with it: not follow, and a command that needs a terminal, such as `camel debug`, exits with `2` instead of hanging a CI job. * `camel stop` and `camel restart` wait until the integration has stopped, and exit with `124` when it did not stop in time. +* `camel stop` without a name stops the integration that runs. When several run, it stops none, lists them, and exits + with `2`: give the name, or `--all` to stop them all. When we had agents test the CLI, the bare `camel stop` of one + agent stopped the integrations of the others. +* A kill of `camel run --jvm-args=...` or `--jvm-debug`, as a supervisor or an agent sends it, stops the JVM that runs + the integration too. It kept running, with nothing left to stop it. * `camel run --background` waits for the integration to start, and a file that does not exist fails before anything starts. * A route that fails to start exits with `1`, which says "fix the route", with one line on stderr: the stack trace @@ -154,13 +164,21 @@ And with it: problem, and that still exits with `1`. `camel version set 9.9.9` refuses it, where it stored it for every later command to fail on. * `X=$(camel eval expression ...)` is only the value. The Camel that `camel eval` starts for itself printed its state - first. + first. A syntax error prints what is wrong, without the 30 lines of stack trace before it, and `--json` gives the + value or the error as JSON. * The `--timeout` of `camel cmd send` bounds the send, not only the wait of the CLI. A send to `direct:nope` waited 30 seconds for a consumer and ended in a timeout of the CLI; now it fails at once with "No consumers available". * Options do with `--json` what they do without: `camel cmd route-structure --json --filter=orders` printed every route, and a filter that matches nothing exits with `3`. `camel cmd receive --output=json` has only JSON on stdout. * A row of a JSON listing says which integration it is of, with `pid` as a number and `name`, and a list is a list also for one integration. +* `camel cmd send --json` prints the outcome of the send, and the reply, as one JSON object, and `camel trace + --action=dump --json` prints one JSON object per trace, a line each. +* Only the result goes to stdout: `camel generate schema --verbose` tells what it does on stderr, and `camel generate + rest` prints only the REST DSL, where the banner of the OpenAPI generator made `> rest.xml` invalid XML. +* A missing argument says `Missing argument: ...`, with the usage line under it, where `camel doc` printed its whole + description. +* `camel mcp` without JBang says how to run the MCP server without it, where it exited with `70` and a stack trace. The AI tools of the Camel CLI, the [MCP server](/manual/camel-jbang-mcp.html) and `camel ask`, pass these failures on to the agent as errors, so the model sees what went wrong instead of guessing it. And they act on the integration the @@ -171,6 +189,13 @@ YAML. The lines of source code in the answers are as they are in the file, witho catalog, such as `kafak`, suggests `kafka`, and asking for it a third time says so again, rather than to go on with the options the answer gave. +The MCP server names its own tools in its answers: some answers named the tools of `camel ask`, which the server does +not have. Every tool costs context in every session, so `camel_dependency_check` now does the security audit as well, +and four tools that were stale are gone. `camel_render_route_diagram` works when it is called several times at once, +and is a second faster. In `camel ask`, the code of an answer is checked, and an option that does not exist is marked. +A chat keeps its history bounded, and a question that fails leaves no trace in it. And the AI clients of the CLI work +with the current Claude models. + ### Keeping up with the agent An agent does not only start commands, it talks to the integration it is building: it sends a message, reloads a @@ -188,6 +213,12 @@ of their own: * **`camel status --json`** is the state of an integration in one call: its routes, the problems first, the last errors and log lines, the HTTP endpoints, and the oldest exchange in flight. In about 0.3 s, where `camel get route`, `get health`, `get error` and `camel log` took about a second together. +* **A send that waits does not hold up the rest.** A `camel cmd send` that waits, such as a `--poll` of an empty + endpoint, held up `camel stop` (22 seconds in our test) and the status of the integration. A send now runs on a + thread of its own. +* **The trace file stays small.** With tracing on, the trace file grew without end, about 15 MB a minute at 100 + messages a second, and `camel trace` read it all each time. It starts again at 10 MB, and `camel trace` follows the + new file. Fast and trustworthy go together: the agent calls the CLI often because each call is cheap, and it can act on what comes back because the answer is right. @@ -252,7 +283,10 @@ Nightly builds are development builds for testing, not Apache releases. and `camel.bat` has Windows line endings. * `camel kubernetes` honours `--kube-config` in all commands, and `camel kubernetes logs` stops at a pod that has finished. `camel kubernetes export` puts `--env`, `--config`, `--volume`, `--label` and `--annotation` in a CronJob - and a Knative Service too, where they were dropped without a word. + and a Knative Service too, where they were dropped without a word. A configmap and a secret of the same name are two + volumes, a cron schedule such as `0 1,13 * * *` keeps its comma, `--profile` keeps the traits of + `application.properties`, and `--trait route.annotations=k=v` gives an annotation. `camel kubernetes delete` deletes + the CronJob too. * `camel debug --breakpoint tick` and `--source-dir` work; the debug options were taken apart wrongly before they went to `camel run`. * `camel init` gives a Kamelet its kind from the file name, puts `./x.yaml` in `--dir`, and refuses a Java file whose @@ -261,8 +295,21 @@ Nightly builds are development builds for testing, not Apache releases. * `camel infra stop --kill` no longer kills a process that got the pid of a service that was killed hard. * `camel cmd logger --logging-level=BOGUS` is a usage error instead of setting the level to `ERROR`, and `camel cmd browse --endpoint=seda:foo`, the example of its own help, finds `seda://foo`. -* `camel generate rest --routes` writes routes that validate and run, with a log step to replace, and `camel test init` - does not overwrite a test you edited, unless `--force`. +* `camel generate rest --routes` writes routes that validate and run, with a log step to replace, and the DTOs it + generates compile in a Camel 4 project, with `jakarta` imports. `camel test init` does not overwrite a test you + edited, unless `--force`. +* `camel get consumer` and `camel get producer` work again: in 4.23 they failed with exit `70` for an integration with + a consumer. `camel get transformer` no longer warns for each integration without transformers. +* `camel dependency copy` resolves the dependencies together, so `lib/` has one version of each library, and `camel + dependency update` keeps the line endings of the file. +* A plugin built for another Camel version no longer stops `camel run` and `camel export`: they warn and go on without + it. +* `camel run --example ... --background` deletes the folder of the example when the integration stops. `--profile` + reads `application-.properties` next to `application.properties`, not from the current directory, and the + port of `platform-http` is the one of the run, not of an earlier run in the same directory. +* `camel catalog --filter=aws2` matches a part of a name, the options of `camel update run` are kebab-case (`--dry-run`, + the camelCase names still work), `camel transform route --output=Out.java` names the class `Out`, and a completion in + `camel edit` keeps the rest of the line. ## Try it From 39dea71654d597b5df671c3c8ef26f702e03f917 Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Sun, 15 Nov 2026 20:43:45 +0100 Subject: [PATCH 08/11] Blog: Camel CLI 4.24 - the next step of the start time, in aesh#779 Co-Authored-By: Claude Opus 5.5 Signed-off-by: Claus Ibsen --- content/blog/2026/11/camel-cli-424/index.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index 8f489bafdad..0c6ce431e81 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -60,6 +60,10 @@ Where did the second go? Not into one big fix, but many small ones, found by mea 256 ms. * **aesh.** More about that below. +And there is more to come. At the start of each command, aesh looks through all 344 jars of the CLI for its registry +of commands, which only its own jar has. We asked for a way to skip that search +([aesh#779](https://github.com/aeshell/aesh/issues/779)), which should take about another 40 ms off every command. + ## On aesh instead of picocli The Camel CLI has used [picocli](https://picocli.info/) from its start. picocli served us well, but it moves slowly From e720fa027472548f6c0c88521a74818a8ab1597e Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Mon, 16 Nov 2026 22:32:10 +0100 Subject: [PATCH 09/11] Blog: Camel CLI 4.24 - shorter, focused on being fast so an AI can use it first-class Co-Authored-By: Claude Opus 5.5 --- content/blog/2026/11/camel-cli-424/index.md | 365 +++++--------------- 1 file changed, 95 insertions(+), 270 deletions(-) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index 0c6ce431e81..f6897969960 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -1,28 +1,41 @@ --- -title: "The Camel CLI in Camel 4.24: starts in a blink, now on aesh" +title: "The Camel CLI in Camel 4.24: fast, so an AI can use it first-class" date: 2026-11-17 draft: false authors: [davsclaus] categories: ["Camel", "Tooling"] keywords: ["apache camel", "camel cli", "camel 4.24", "aesh", "picocli", "startup", "class data sharing", "exit codes", "ai agents", "self-update"] -preview: "The Camel CLI in Camel 4.24 runs a command in about 125 ms, where 4.23 took more than a second. It parses its command lines with aesh instead of picocli, and it is a CLI an AI agent can trust and keep up with: documented exit codes, errors on stderr, JSON output and timeouts." +preview: "The Camel CLI in Camel 4.24 runs a command in about 125 ms, where 4.23 took more than a second. That is on purpose: an AI agent calls the CLI 50 or 100 times for one task, and the CLI must be fast, and its answers right, for the agent to use it as a first-class tool. And it now runs on aesh, built together with its maintainer." --- You type `camel` many times a day: `camel run`, `camel ps`, `camel get route`, `camel log`. And now so do AI agents, -which call the CLI over and over in a loop. In Camel 4.24 the Camel CLI got a lot of attention. This post is about -three changes: +which call the CLI over and over in a loop. In Camel 4.24 we made the Camel CLI a first-class tool for an AI agent: -* it is fast: a command such as `camel version` or `camel ps` takes about 125 ms, where 4.23 took more than a second -* it runs on [aesh](https://github.com/aeshell/aesh) instead of picocli -* it is a CLI an AI agent can trust: exit codes, errors on stderr, JSON output and timeouts +* it is **fast**: a command takes about 125 ms, where 4.23 took more than a second +* it gives **answers an agent can trust**: exit codes, errors on stderr, JSON output and timeouts +* it runs on [aesh](https://github.com/aeshell/aesh) instead of picocli, and we built that together with its maintainer -And then some of the smaller things that make the day better. +## Why fast is the point + +An agent works in a loop: it runs a command, reads what came back, decides the next step, and runs the next command. +To build and fix an integration it looks up a component, writes a route, validates it, runs it, reads the log, sends +a message, checks the routes, and goes around again. That is easily 50 or 100 calls of the CLI for one task. + +When you type a command, one second is a short pause. For an agent, every call is a stop: the loop waits for the CLI +before the model can think about the next step. 100 calls of a CLI that takes 1.2 seconds is two minutes of waiting. +At 125 ms it is less than 13 seconds. + +And it is not only about time. When a check is cheap, an agent does it: it looks up the option instead of guessing +it, it validates after each change, and it checks the routes once more after the reload. When every call costs a +second, there are fewer of those checks, and more guessing. A fast CLI makes the agent quicker, and it makes it +better, because it can afford to verify. With a local model, where the model is already the slow part, you want +every other part of the loop to be as fast as possible. + +So being fast was not a nice side effect. It was the goal. ## Fast -This is the time a command takes, from typing it to the prompt coming back. It is the median of 15 runs of the -`camel` launcher of the distribution (4.23.0, and 4.24 built from main), after 3 runs to warm up, on an Apple M4 Pro -with Java 25: +This is the time a command takes, from typing it to the prompt coming back (median of 15 runs, Apple M4 Pro, Java 25): | Command | Camel 4.23 | Camel 4.24 | |--------------------|-----------:|-----------:| @@ -33,287 +46,92 @@ with Java 25: | `camel run --help` | 1202 ms | 256 ms | | `camel --help` | 1198 ms | 256 ms | -That is about 10 times faster for the commands you use the most. A `camel ps` now comes back before you notice it -was gone. For you that is nice. For an AI agent it matters much more, as we will see below. - -Where did the second go? Not into one big fix, but many small ones, found by measuring first: - -* **Only the command you run is created.** The Camel CLI has more than 160 commands. Camel 4.23 created all of them, - with all their options, and those of every plugin, before it ran one. Now `camel ps` creates `camel ps`, and a - plugin command creates only that plugin. -* **No logging unless something logs.** Most commands log nothing, yet log4j was started for each of them. Also the - check for a newer version of the CLI started log4j, before every command. And a Camel class that only has a logger - no longer starts it either. `camel ps` loads 1,591 classes, and none of log4j or Jackson. In 4.23 it loaded 5,373, - of which 704 were of log4j. -* **No terminal when there is none.** A command whose output goes to a file or a pipe built a terminal only to find - out that there was none, to leave out the colors. -* **The launcher script no longer runs `java -version`** to find out the Java version. It reads the release file of - the JDK instead, which saves starting a second JVM. -* **The JVM no longer waits at exit** for the thread of an HTTP client that a command created but never used, or - for the update check. -* **The distribution runs from plain jars.** Camel 4.23 ran the CLI from one Spring Boot fat jar, which has its own - class loader for the nested jars. Camel 4.24 has the jars in `lib/`, next to a thin launcher jar. -* **Class data sharing.** Because the jars are plain jars now, the JVM can keep the classes a command loads in an - archive, and map it in on the next run. The `camel` script does this by itself: the first run of a command writes - the archive (under `~/.cache/camel-cli/cds/`), and the runs after it are faster. Set `CAMEL_CDS=false` to turn it - off. Without the archive, `camel version` takes 154 ms instead of 128 ms, and `camel --help` 411 ms instead of - 256 ms. -* **aesh.** More about that below. +That is about 10 times faster for the commands you, and your agent, use the most. -And there is more to come. At the start of each command, aesh looks through all 344 jars of the CLI for its registry -of commands, which only its own jar has. We asked for a way to skip that search -([aesh#779](https://github.com/aeshell/aesh/issues/779)), which should take about another 40 ms off every command. - -## On aesh instead of picocli - -The Camel CLI has used [picocli](https://picocli.info/) from its start. picocli served us well, but it moves slowly -now: its last release was in April 2025. In Camel 4.24 the Camel CLI parses its command lines, prints its help and -completes its commands with [aesh](https://github.com/aeshell/aesh), the Java library for command line tools by -Ståle Pedersen. +There was no one big fix, but many small ones, found by measuring first. The biggest: -The main reason for the move is not speed. It is that aesh is a living project, with a maintainer we can talk to. We -saw that during the port. Before switching, we ported all of the CLI on a branch and wrote down every gap and bug we -found in aesh: 36 issues and 17 pull requests. Ståle fixed or merged nearly all of them within days, and released aesh -3.19 and 3.19.1 with them. Thank you, Ståle! - -aesh is a little faster too. In our measurements during the port, aesh took about 20 ms off `camel version`, and -about 60 ms off `camel --help`. That is a small part of the second above, but it all adds up. - -### What changes for you - -For using the Camel CLI, not much. The commands and their options are the same. To be sure of that, before the -switch we wrote a test with 2207 command lines and what picocli made of them, and one with the help of all commands -and the errors of wrong command lines. The aesh port had to give the same answers. - -The help looks a little different: the default value of an option is on a line of its own (`Default: ...`). - -An argument `@file` is replaced by the arguments in that file, as it was with picocli, such as `camel @run.txt`. - -If you wrote your own plugin for the Camel CLI, it must be changed and built for Camel 4.24: a plugin adds its -commands to a `CommandTree` instead of a picocli `CommandLine`, and the commands use the aesh annotations. The -[upgrade guide](/manual/camel-4x-upgrade-guide-4_24.html) has the details. - -## A CLI that an AI can trust, and that keeps up with it +* **Only the command you run is created.** The CLI has more than 160 commands, and 4.23 created all of them, and + those of every plugin, before it ran one. Now `camel ps` creates only `camel ps`. +* **Only the jars and classes it needs.** A short command no longer looks through all 344 jars of the CLI, and no + longer starts log4j when nothing logs. `camel ps` loads 1,591 classes, where 4.23 loaded 5,373. +* **Plain jars and class data sharing.** The distribution runs from plain jars instead of a Spring Boot fat jar, so + the JVM can keep the classes a command loads in an archive, and map it in on the next run. The `camel` script does + this by itself (set `CAMEL_CDS=false` to turn it off). +* **aesh.** More about that below. -More and more, the Camel CLI is not called by a person, but by an AI agent. The agent works in a loop: it runs a -command, reads what came back, decides the next step, and runs the next command. To build and fix an integration it -looks up a component, writes a route, validates it, runs it, reads the log, sends a message, checks the routes, and -goes around again. That is easily 50 or 100 calls of the CLI for one task. +## Answers an AI can trust -### Fast matters more for an AI than for you +Fast is not enough. An agent cannot see your screen: all it has is the exit code and the text that came back, and it +builds its next step on that. A person reads "ERROR: no integration found" and knows what to do, even when the exit +code says `0`. An agent takes the `0` as a fact, and goes down the wrong path. A command that waits for a terminal +that is not there leaves the agent stuck until its own timeout. -When you type a command, one second is a short pause. You were reading the last output anyway. For an agent, every -call is a stop: the loop waits for the CLI before the model can think about the next step. 100 calls of a CLI that -takes 1.2 seconds is two minutes of waiting. At 125 ms it is less than 13 seconds. +So in Camel 4.24 the Camel CLI has a contract: the [exit codes and output](/manual/camel-jbang-exit-codes.html). +It is good for a script and a CI job too: -And it is not only about time. When a check is cheap, an agent does it: it looks up the option instead of guessing -it, it validates after each change, and it checks the routes once more after the reload. When every call costs a -second, there are fewer of those checks for the same time and the same budget, and more guessing. A fast CLI makes the -agent quicker, and it makes it better, because it can afford to verify. Running a local model, where the model is -already the slow part, you want every other part of the loop to be as fast as possible. - -### An answer an AI can trust - -An agent cannot see your screen. All it has is the exit code and the text that came back, and it builds its next -step on that. A person reads "ERROR: no integration found" and knows what to do, even when the exit code says `0`. An -agent that gets `0` for a command that did not work takes it as a fact, and goes down the wrong path. A command that -waits for a terminal that is not there leaves the agent stuck until its own timeout. Every answer the CLI gets wrong -costs the agent more than the command took. - -So in Camel 4.24 the Camel CLI has a contract: the -[exit codes and output](/manual/camel-jbang-exit-codes.html). The same contract is good for a script and a CI job too: - -| Exit code | Meaning | -|----------:|----------------------------------------------------------------| -| 0 | success | -| 1 | the command failed | -| 2 | usage error: a wrong option or argument | +| Exit code | Meaning | +|----------:|------------------------------------------------------------------| +| 0 | success | +| 1 | the command failed | +| 2 | usage error: a wrong option or argument | | 3 | not found: no integration, route, Kamelet or plugin of that name | -| 66 | a file or directory that does not exist | -| 70 | internal error | -| 124 | timed out: the integration did not answer in time | +| 66 | a file or directory that does not exist | +| 70 | internal error | +| 124 | timed out: the integration did not answer in time | And with it: * Errors go to stderr, so the output on stdout can be read as is. -* With `--json`, stdout is exactly one JSON document, also when the command fails, so it can always be parsed. A - listing with nothing in it prints `[]`. -* Commands that talk to a running integration take a `--timeout`, and say so when the integration did not answer, - instead of waiting forever. -* No command waits for a terminal that is not there. Without one, `--watch` shows the output once, `camel log` does - not follow, and a command that needs a terminal, such as `camel debug`, exits with `2` instead of hanging a CI job. -* `camel stop` and `camel restart` wait until the integration has stopped, and exit with `124` when it did not stop - in time. -* `camel stop` without a name stops the integration that runs. When several run, it stops none, lists them, and exits - with `2`: give the name, or `--all` to stop them all. When we had agents test the CLI, the bare `camel stop` of one - agent stopped the integrations of the others. -* A kill of `camel run --jvm-args=...` or `--jvm-debug`, as a supervisor or an agent sends it, stops the JVM that runs - the integration too. It kept running, with nothing left to stop it. -* `camel run --background` waits for the integration to start, and a file that does not exist fails before anything - starts. -* A route that fails to start exits with `1`, which says "fix the route", with one line on stderr: the stack trace - is in the log already. Before, it was `70`, which says "a bug in Camel, do not retry", so an agent gave up instead of - fixing its route. -* With `orders` and `orders-v2` running, `camel stop orders` stops `orders`. A name was a prefix only, so it stopped - both, and every command for one integration failed for `orders`. A name that no integration has is still a prefix. -* An option given on the command line wins over `application.properties`. With `camel.main.tracing=false` in the - file, `camel run --trace` printed no trace. -* No ANSI color codes when the output is a file or a pipe, unless `--logging-color` is given: `camel cmd send - --reply | cat` had them. -* `camel validate` exits with `66` for a file that does not exist, and for nothing to validate. It said "Validation - success (files:0)" for a `notes.txt`. So do `camel export`, `camel dependency` and `camel transform route` for a - file that does not exist, with the message on stderr. -* A `--camel-version` that was never released says `Camel version 9.9.9 not found` and exits with `3`, in `camel - catalog`, `camel doc` and `camel validate`. It said "Cannot resolve dependencies", which reads like a network - problem, and that still exits with `1`. `camel version set 9.9.9` refuses it, where it stored it for every later - command to fail on. -* `X=$(camel eval expression ...)` is only the value. The Camel that `camel eval` starts for itself printed its state - first. A syntax error prints what is wrong, without the 30 lines of stack trace before it, and `--json` gives the - value or the error as JSON. -* The `--timeout` of `camel cmd send` bounds the send, not only the wait of the CLI. A send to `direct:nope` waited - 30 seconds for a consumer and ended in a timeout of the CLI; now it fails at once with "No consumers available". -* Options do with `--json` what they do without: `camel cmd route-structure --json --filter=orders` printed every - route, and a filter that matches nothing exits with `3`. `camel cmd receive --output=json` has only JSON on stdout. -* A row of a JSON listing says which integration it is of, with `pid` as a number and `name`, and a list is a list - also for one integration. -* `camel cmd send --json` prints the outcome of the send, and the reply, as one JSON object, and `camel trace - --action=dump --json` prints one JSON object per trace, a line each. -* Only the result goes to stdout: `camel generate schema --verbose` tells what it does on stderr, and `camel generate - rest` prints only the REST DSL, where the banner of the OpenAPI generator made `> rest.xml` invalid XML. -* A missing argument says `Missing argument: ...`, with the usage line under it, where `camel doc` printed its whole - description. -* `camel mcp` without JBang says how to run the MCP server without it, where it exited with `70` and a stack trace. - -The AI tools of the Camel CLI, the [MCP server](/manual/camel-jbang-mcp.html) and `camel ask`, pass these failures on -to the agent as errors, so the model sees what went wrong instead of guessing it. And they act on the integration the -agent named: a runtime tool takes the integration as `nameOrPid`, `name` or `pid`, where a `name` was ignored and the -tool acted on the only integration that ran, which could be another app. `camel_get_files` reads a large file in parts, -instead of an answer of a million tokens, and `camel_edit_file` keeps a `replace` of only whitespace, which matters in -YAML. The lines of source code in the answers are as they are in the file, without `\"`, and a misspelled name in the -catalog, such as `kafak`, suggests `kafka`, and asking for it a third time says so again, rather than to go on with -the options the answer gave. - -The MCP server names its own tools in its answers: some answers named the tools of `camel ask`, which the server does -not have. Every tool costs context in every session, so `camel_dependency_check` now does the security audit as well, -and four tools that were stale are gone. `camel_render_route_diagram` works when it is called several times at once, -and is a second faster. In `camel ask`, the code of an answer is checked, and an option that does not exist is marked. -A chat keeps its history bounded, and a question that fails leaves no trace in it. And the AI clients of the CLI work -with the current Claude models. - -### Keeping up with the agent - -An agent does not only start commands, it talks to the integration it is building: it sends a message, reloads a -changed route, and asks how the integration is doing. In Camel 4.24 those got faster, and some of them got a command -of their own: +* With `--json`, stdout is exactly one JSON document, also when the command fails. +* Commands that talk to a running integration take a `--timeout`, instead of waiting forever. +* No command waits for a terminal that is not there. + +We tested this by letting agents use the CLI, and fixed what tripped them up. The +[MCP server](/manual/camel-jbang-mcp.html) and `camel ask` pass these failures on to the agent as errors, so the model +sees what went wrong instead of guessing it. + +## Keeping up with the agent + +An agent does not only start commands, it talks to the integration it is building. Those got faster too: * **An action is answered in about 25 ms**, such as `camel cmd send` or `camel get route`, where it took about 110 ms. - The CLI and the integration looked for each other's files every 100 ms; now they look much more often, but only - read the folder when it changed. -* **`camel run --background` returns when the routes are up**, about 0.4 s after Camel started, where it was about - 1.3 s. The integration writes its status at once when it has started, instead of on the next tick of a second. -* **`camel cmd reload --wait --json`** reloads the changed files of an integration in dev mode at once, and says how it - went: `reloaded`, `unchanged` or `failed`, with the error. Before, an agent wrote a file and then had to guess when - the reload had happened. +* **`camel run --background` returns when the routes are up**, about 0.4 s after Camel started, where it was 1.3 s. +* **`camel cmd reload --wait --json`** reloads the changed files in dev mode at once, and says if it was `reloaded`, + `unchanged` or `failed`. Before, an agent wrote a file and had to guess when the reload had happened. * **`camel status --json`** is the state of an integration in one call: its routes, the problems first, the - last errors and log lines, the HTTP endpoints, and the oldest exchange in flight. In about 0.3 s, where `camel get - route`, `get health`, `get error` and `camel log` took about a second together. -* **A send that waits does not hold up the rest.** A `camel cmd send` that waits, such as a `--poll` of an empty - endpoint, held up `camel stop` (22 seconds in our test) and the status of the integration. A send now runs on a - thread of its own. -* **The trace file stays small.** With tracing on, the trace file grew without end, about 15 MB a minute at 100 - messages a second, and `camel trace` read it all each time. It starts again at 10 MB, and `camel trace` follows the - new file. + last errors and log lines, and the HTTP endpoints. In about 0.3 s, where four commands took about a second. Fast and trustworthy go together: the agent calls the CLI often because each call is cheap, and it can act on what comes back because the answer is right. -## Stay up to date - -The [web installer](/manual/camel-jbang-launcher-install.html) installs the latest release: +## On aesh instead of picocli -```shell -curl -fsSL https://camel.apache.org/install.sh | sh -``` +The Camel CLI has used [picocli](https://picocli.info/) from its start. picocli served us well, but it moves slowly +now: its last release was in April 2025. In Camel 4.24 the Camel CLI parses its command lines, prints its help and +completes its commands with [aesh](https://github.com/aeshell/aesh), the Java library for command line tools by +Ståle Pedersen. -You can ask it for the newest LTS release, or the newest release of a line, and `camel self-update` stays on it: +The main reason for the move is not speed. It is that aesh is a living project, with a maintainer we can talk to. We +saw that during the port. Before switching, we ported all of the CLI on a branch and wrote down every gap and bug we +found in aesh: 36 issues and 17 pull requests. Ståle fixed or merged nearly all of them within days, and released aesh +3.19 and 3.19.1 with them. -```shell -curl -fsSL https://camel.apache.org/install.sh | sh -s -- --version LTS -curl -fsSL https://camel.apache.org/install.sh | sh -s -- --version 4.24 -``` +aesh is a little faster too. In our measurements during the port, aesh took about 20 ms off `camel version`, and +about 60 ms off `camel --help`. -And new in 4.24: try what is coming before it is released. Apache publishes a nightly build of the Camel CLI, and -`camel self-update` can switch to it, and back: +And it did not stop there. At the start of each command, aesh looked through all 344 jars of the CLI for its registry +of commands, which only its own jar has. We asked for a way to skip that search +([aesh#779](https://github.com/aeshell/aesh/issues/779)), and for aesh to start its logging only when it logs +([aesh#782](https://github.com/aeshell/aesh/issues/782)). Ståle has added both already, and they take about another +30 ms off `camel ps` in our test. That comes with the next release of aesh. -```shell -camel self-update --version SNAPSHOT -``` +This is what open source at its best looks like: two projects that find a problem, talk about it, and fix it +together, in days. Thank you, Ståle! -Nightly builds are development builds for testing, not Apache releases. - -## The smaller things - -* `camel cmd send` can feed a route: `--repeat` and `--interval` send many messages, and `--body=file:` sends the - files of a folder, one message per file. - - ```shell - camel cmd send --endpoint=kafka:refunds --body=file:refund.json --repeat=50 --interval=100..500 - ``` - -* `camel run --data-dir` names the folders with data files under the source directory, which dev mode does not watch, - so writing a file there does not reload the routes. Nor do the files a run writes itself: `camel dev > run.log` - reloaded the routes every 2 seconds. Log files, `target`, `.git` and the `.camel` folders are not watched. -* In dev mode, a change of `application.properties` is reloaded, and with files in two folders, such as - `camel run a.camel.yaml other/b.camel.yaml --dev`, both are watched: only the folder of `b.camel.yaml` was. -* `camel run '*'` works when the shell does not expand the `*`, such as the Windows command prompt: it said "No - routes found in: *". -* A value in the configuration that an option does not take, such as `runtime=springboot`, says which file, key and - value; every command with `--runtime` failed with "DefaultValueProvider failed for option runtime". `camel config - set` refuses such a value, and `camel config unset` of a key that is not set exits with `3`. -* `--exclude` takes a folder, such as `--exclude=sub/**`, and works for `camel run .`, `--source-dir` and `camel dev`, - where it was left out. -* In dev mode, a reload applies changed `camel.beans` and `camel.component` properties, and a dependency added to - `camel.jbang.dependencies` while the app runs is downloaded. -* The log of the previous run is kept, also for the Spring Boot and Quarkus runtimes, so you can read why it failed - at startup. `camel dirty --clean` removes those logs too. -* `camel cmd route-diagram`, `route-structure` and `route-topology` read Java routes with the Java DSL parser, without - compiling them. -* `camel cmd send --body=...` without a name sends to the integration that runs, such as after `camel run --stub=jms`. - It sent to an empty Camel of its own, and said "Sent (success)". An endpoint of a system outside the integrations, - such as `kafka:topic`, is still sent from the CLI. -* A `camel-cli.properties` in the current directory is laid over the global `~/.camel-cli.properties`, rather than - hiding all of it. -* From the launcher, `camel export` exports the Citrus tests, `--jvm-debug` and `--jvm-args` work without JBang, - and `camel.bat` has Windows line endings. -* `camel kubernetes` honours `--kube-config` in all commands, and `camel kubernetes logs` stops at a pod that has - finished. `camel kubernetes export` puts `--env`, `--config`, `--volume`, `--label` and `--annotation` in a CronJob - and a Knative Service too, where they were dropped without a word. A configmap and a secret of the same name are two - volumes, a cron schedule such as `0 1,13 * * *` keeps its comma, `--profile` keeps the traits of - `application.properties`, and `--trait route.annotations=k=v` gives an annotation. `camel kubernetes delete` deletes - the CronJob too. -* `camel debug --breakpoint tick` and `--source-dir` work; the debug options were taken apart wrongly before they went - to `camel run`. -* `camel init` gives a Kamelet its kind from the file name, puts `./x.yaml` in `--dir`, and refuses a Java file whose - name is not a class name, such as `my-route.java`. -* `camel doctor` checks a nightly build against the Apache snapshots, where it reported Maven as failed. -* `camel infra stop --kill` no longer kills a process that got the pid of a service that was killed hard. -* `camel cmd logger --logging-level=BOGUS` is a usage error instead of setting the level to `ERROR`, and - `camel cmd browse --endpoint=seda:foo`, the example of its own help, finds `seda://foo`. -* `camel generate rest --routes` writes routes that validate and run, with a log step to replace, and the DTOs it - generates compile in a Camel 4 project, with `jakarta` imports. `camel test init` does not overwrite a test you - edited, unless `--force`. -* `camel get consumer` and `camel get producer` work again: in 4.23 they failed with exit `70` for an integration with - a consumer. `camel get transformer` no longer warns for each integration without transformers. -* `camel dependency copy` resolves the dependencies together, so `lib/` has one version of each library, and `camel - dependency update` keeps the line endings of the file. -* A plugin built for another Camel version no longer stops `camel run` and `camel export`: they warn and go on without - it. -* `camel run --example ... --background` deletes the folder of the example when the integration stops. `--profile` - reads `application-.properties` next to `application.properties`, not from the current directory, and the - port of `platform-http` is the one of the run, not of an earlier run in the same directory. -* `camel catalog --filter=aws2` matches a part of a name, the options of `camel update run` are kebab-case (`--dry-run`, - the camelCase names still work), `camel transform route --output=Out.java` names the class `Out`, and a completion in - `camel edit` keeps the rest of the line. +For using the Camel CLI, not much changes. The commands and their options are the same: before the switch we wrote a +test with 2207 command lines and what picocli made of them, and the aesh port had to give the same answers. If you +wrote your own plugin for the Camel CLI, it must be changed for aesh; the +[upgrade guide](/manual/camel-4x-upgrade-guide-4_24.html) has the details. ## Try it @@ -323,7 +141,14 @@ Try it now with the nightly build: camel self-update --version SNAPSHOT ``` -When Camel 4.24 is released, `camel self-update --version 4.24` switches back to the releases. Or install it with the -web installer above. +Nightly builds are development builds for testing, not Apache releases. When Camel 4.24 is released, +`camel self-update --version 4.24` switches back to the releases. Or install it with the +[web installer](/manual/camel-jbang-launcher-install.html): + +```shell +curl -fsSL https://camel.apache.org/install.sh | sh +``` + +Camel 4.24 also has many smaller fixes and improvements to the CLI; see the release notes for all of them. And then type `camel ps`, and see how fast it comes back. From c7bac4d8ba3cecde6345d635f8295c4899351ad1 Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Mon, 16 Nov 2026 22:38:39 +0100 Subject: [PATCH 10/11] Blog: Camel CLI 4.24 - the --help numbers are only to compare, and camel run has a faster Maven downloader Co-Authored-By: Claude Opus 5.5 --- content/blog/2026/11/camel-cli-424/index.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/content/blog/2026/11/camel-cli-424/index.md b/content/blog/2026/11/camel-cli-424/index.md index f6897969960..9323c7241cc 100644 --- a/content/blog/2026/11/camel-cli-424/index.md +++ b/content/blog/2026/11/camel-cli-424/index.md @@ -48,6 +48,14 @@ This is the time a command takes, from typing it to the prompt coming back (medi That is about 10 times faster for the commands you, and your agent, use the most. +We use commands such as `camel version` and `--help` to compare, because they do nothing but start the CLI, so the +numbers show the CLI itself. The same second is gone from every command: `camel run foo.java` starts the CLI the +same way, and saves that second too, before your route even starts. + +And `camel run` got faster on top of that, as the Maven downloader of the CLI is faster in general: it resolves the +dependencies together and downloads them in parallel, it does not download what the CLI already has, and it does not +keep asking a Maven repository that cannot be reached. + There was no one big fix, but many small ones, found by measuring first. The biggest: * **Only the command you run is created.** The CLI has more than 160 commands, and 4.23 created all of them, and From 0428b15fa31d3d2699ac81faa54ec3c6854bbe0a Mon Sep 17 00:00:00 2001 From: Claus Ibsen Date: Mon, 16 Nov 2026 22:48:42 +0100 Subject: [PATCH 11/11] Blog: Camel CLI 4.24 - featured image Co-Authored-By: Claude Opus 5.5 --- .../blog/2026/11/camel-cli-424/featured.jpg | Bin 0 -> 392534 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 content/blog/2026/11/camel-cli-424/featured.jpg diff --git a/content/blog/2026/11/camel-cli-424/featured.jpg b/content/blog/2026/11/camel-cli-424/featured.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cf28d895014e8a43dc7eca28e1be86b98446e1b3 GIT binary patch literal 392534 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