@alt-javascript/camel-lite-cli 1.0.2 → 1.1.1

package/README.md

@@ -1,52 +1,226 @@
 # camel-lite-cli
 
-Command-line runtime for camel-lite. Load a route definition file and optionally inject a single message into the first `from:` endpoint.
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)
+
+Command-line runtime for camel-lite. Load a route definition and run it — inject a single message, receive messages from a URI, or keep the context alive in daemon mode.
 
 ## Install
 
 ```sh
-npm install -g camel-lite-cli
+npm install -g @alt-javascript/camel-lite-cli
 ```
 
-## Usage
+## Quick Start
 
 ```sh
-# Run a route file (daemon mode implied — exits when the route finishes)
+# Run a route file silently
 camel-lite -r route.yaml
 
-# Inject a JSON body and exit
+# Inject a JSON body and print any reply
 camel-lite -r route.yaml -i '{"name":"world"}'
 
-# Read the message body from stdin
-camel-lite -r route.yaml -i -
+# Keep a timer route running until Ctrl-C
+camel-lite -r timer-route.yaml -d
+
+# Consume messages from a URI and print each body to stdout
+camel-lite -r route.yaml -c seda:orders
+
+# Show framework logs while debugging a route
+camel-lite --debug -r route.yaml -i '{"name":"world"}'
+```
+
+## Usage
+
+```
+camel-lite -r <file|-> [options]
+```
+
+### Required
+
+| Flag | Description |
+|------|-------------|
+| `-r`, `--routes <file\|->` | Route definition file (`.yaml`, `.yml`, `.json`) or `-` to read from stdin |
+
+### Input / Output
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-i`, `--input <body\|->` | Message body to inject into the first `from:` endpoint. Accepts a JSON string, a plain string, or `-` to read from stdin | *(none — no message sent)* |
+| `-p`, `--producer-uri <uri>` | Override the target endpoint URI for `-i`. Requires `-i`. Default: the first route's `from:` URI | *(first route `from:` URI)* |
+| `--exchange-pattern <pattern>` | `InOnly` or `i` — fire-and-forget (exit after send). `InOut` or `io` — request-reply (prints reply body to stdout). Case-insensitive. | `InOnly` |
+| `-c`, `--consumer-uri <uri>` | Poll a consumer URI in a daemon loop, printing each message body to stdout. Implies daemon mode. Mutually exclusive with `-i` and `-p` | *(none)* |
+
+### Runtime Behaviour
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-d`, `--daemon` | Keep the context alive until `SIGINT`/`SIGTERM`. Use for timer, cron, and seda-driven routes | `false` |
+| `-l`, `--log-mode <text\|json>` | Log output format: `text` (human-readable) or `json` (structured JSON objects) | `text` |
+
+### Logging
+
+By default, all camel-lite and boot framework log output is suppressed — the CLI is pipe-friendly and produces zero stderr output unless a flag is set.
+
+| Flag | Description |
+|------|-------------|
+| `--verbose` | Enable info-level framework logging on stderr |
+| `--debug` | Enable debug-level framework logging on stderr. Takes precedence over `--verbose` |
+
+### Other
+
+| Flag | Description |
+|------|-------------|
+| `-v`, `--version` | Print the CLI version and exit |
+| `-h`, `--help` | Print help and exit |
+
+## Flag Constraints
+
+- `-r -` and `-i -` are mutually exclusive: only one argument can read from stdin.
+- `-p` requires `-i`. Specifying a producer URI without a body to send is an error.
+- `-c` is mutually exclusive with `-i` and `-p`. Consumer mode and producer mode are separate operations.
+- `--exchange-pattern` accepts `InOnly`, `i`, `InOut`, or `io` (case-insensitive). Any other value is an error.
+
+## Examples
+
+### Fire-and-forget message
+
+```sh
+camel-lite -r route.yaml -i '{"order":"ABC-1","qty":5}'
+```
+
+Sends the JSON body to the first route's `from:` URI. Exits after the route completes. No output unless the route writes to stdout.
+
+### Request-reply (InOut)
+
+```sh
+camel-lite -r transform-route.yaml -i 'hello' --exchange-pattern InOut
+```
+
+Sends `hello`, waits for the reply, and prints the reply body to stdout.
+
+### Send to a specific endpoint
+
+```sh
+camel-lite -r route.yaml -i '{"event":"login"}' -p seda:audit
+```
+
+Sends the body to `seda:audit` instead of the route's default `from:` URI.
+
+### Read route and body from stdin
+
+```sh
+# Route from stdin, body as argument
+cat route.yaml | camel-lite -r - -i '{"name":"world"}'
 
-# Read the route definition from stdin, inject a literal string body
-cat route.yaml | camel-lite -r - -i body
+# Route as argument, body from stdin
+echo '{"name":"world"}' | camel-lite -r route.yaml -i -
+```
 
-# Daemon mode — keep running after the initial message (timer/cron/seda routes)
-camel-lite -r route.yaml -d
+### Daemon mode
 
-# JSON-structured log output
-camel-lite -l json -r route.yaml
+```sh
+camel-lite -r cron-route.yaml -d
 ```
 
-## Options
+Keeps the context running. Press Ctrl-C or send `SIGTERM` to stop.
+
+### Consumer daemon
+
+```sh
+camel-lite -r route.yaml -c timer:tick?period=1000
+```
+
+Polls `timer:tick` in a loop. Each message body is printed to stdout on a new line. Runs until `SIGINT` or `SIGTERM`.
+
+```sh
+camel-lite -r route.yaml -c seda:results | tee results.log
+```
+
+Pipe consumer output to another tool — the CLI writes one body per line to stdout.
+
+### Logging
+
+```sh
+# Show info-level framework logs (route registration, context start/stop)
+camel-lite --verbose -r route.yaml -i body
+
+# Show debug-level logs (per-message dispatch, timer fires, lock renewal)
+camel-lite --debug -r route.yaml -i body
+
+# --debug wins when both are present
+camel-lite --debug --verbose -r route.yaml -i body
+
+# JSON-structured log lines (combine with --verbose or --debug)
+camel-lite --verbose -l json -r route.yaml -i body
+```
+
+### Missing home config directory
+
+If `~/.camel-lite/` does not exist, the CLI starts silently with no user config. No error is thrown.
+
+## User Configuration
+
+The CLI loads `application.yaml` (or `application.json`) from `~/.camel-lite/` on every invocation. Place component connection strings, default log levels, or any `boot.camel-lite.*` properties there.
+
+```
+~/.camel-lite/
+  application.yaml
+```
+
+Example `~/.camel-lite/application.yaml`:
+
+```yaml
+boot:
+  camel-lite:
+    amqp:
+      url: amqp://localhost:5672
+      username: guest
+      password: guest
+```
+
+Values in `~/.camel-lite/application.yaml` are overridden by the CLI's own `EphemeralConfig` overlay (logging level, banner suppression), and can themselves be overridden by environment variables loaded through the same config chain.
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | Success |
+| `1` | Validation error (bad flags), route error, or unhandled exception |
+
+Error messages are written to stderr in the format `camel-lite: error: <message>`.
+
+## Troubleshooting
+
+**No output in silent mode is expected.** All framework log lines are suppressed by default. Use `--verbose` or `--debug` to see what the route is doing.
+
+**`camel-lite: error: -r / --routes is required`** — The `-r` flag is mandatory. Every invocation must specify a route definition file.
+
+**`camel-lite: error: -p / --producer-uri requires -i / --input`** — You specified a target URI with `-p` but did not provide a body to send. Add `-i <body>`.
+
+**`camel-lite: error: -c / --consumer-uri is mutually exclusive with -i / --input`** — Consumer mode (`-c`) and producer mode (`-i`) cannot be combined. Choose one.
+
+**`camel-lite: fatal: <message>`** — An unhandled exception occurred during CDI boot or route execution. Run with `--debug` to see the full log trace leading up to the error.
+
+**Route exits immediately without processing** — Without `-d` or `-c`, the context stops as soon as the initial message (if any) completes. Add `-d` for timer, cron, or seda-driven routes that need to stay alive.
+
+## Runtime Architecture
 
-| Flag | Long form | Description | Default |
-|------|-----------|-------------|---------|
-| `-r` | `--routes` | Path to route definition file (`.yaml`, `.yml`, `.json`), or `-` to read from stdin | *(required)* |
-| `-i` | `--input` | Message body to inject into the first `from:` endpoint. Accepts a JSON string, a plain string, or `-` to read from stdin | *(none)* |
-| `-d` | `--daemon` | Keep the process running after the initial dispatch. Use for timer/cron/seda-driven routes | `false` |
-| `-l` | `--log-mode` | Log output format: `pretty` (human-readable) or `json` (structured) | `pretty` |
-| `-v` | `--version` | Print the CLI version and exit | — |
+The CLI uses a full CDI boot stack for every invocation:
 
-## Notes
+1. `EphemeralConfig` overlay is constructed with the computed log level and banner suppression.
+2. User config is loaded synchronously from `~/.camel-lite/` via `ProfileConfigLoader`.
+3. A `PropertySourceChain` is composed: overlay (highest priority) → user config.
+4. `Boot.boot({ config })` initialises the CDI container with the chained config.
+5. `camelLiteExtrasStarter` registers all 12 component schemes into the CDI context.
+6. `CdiCamelRuntime` loads the route definition and starts the `CamelContext`.
+7. `ProducerTemplate` or `ConsumerTemplate` performs the requested operation.
+8. The context is stopped (unless `-d` or `-c` keeps it alive).
 
-- All 13 camel-lite components are pre-loaded. Components whose external broker or service is unreachable at startup are skipped gracefully — the route still starts for the components that are available.
-- `-r` and `-i` cannot both be `-` simultaneously. Only one of the two can read from stdin at a time.
-- Route files are loaded via `RouteLoader.loadFile()`. `.yaml` / `.yml` / `.json` extensions are recognised; other extensions trigger content-sniffing.
-- Without `-d`, the process exits after the first message completes its route (or immediately if no `-i` is provided and the route has no self-triggering source).
+All 12 camel-lite component schemes are pre-loaded. Components whose external broker or service is unavailable at startup fail gracefully — the route starts with the available components.
 
 ## See Also
 
 - [camel-lite root README](../../README.md)
+- [camel-lite-core](../camel-lite-core/README.md) — `CamelContext`, `RouteBuilder`, `ProducerTemplate`, `ConsumerTemplate`
+- [boot-camel-lite-starter](../boot-camel-lite-starter/README.md) — CDI auto-configuration for core + 8 components
+- [boot-camel-lite-extras-starter](../boot-camel-lite-extras-starter/README.md) — CDI auto-configuration for amqp/sql/nosql/master

package/bin/camel-lite.js

@@ -5,14 +5,22 @@
  *
  * Usage:
  *   camel-lite -r <route-file|->  [-i <input|->]  [-d]  [-l text|json]
+ *                                 [--verbose]  [--debug]
+ *                                 [-p <uri>]  [--exchange-pattern <i|InOnly|io|InOut>]
+ *                                 [-c <uri>]
  *
  * Options:
- *   -r, --routes <file|->      Route definition file (.yaml/.yml/.json) or - for stdin
- *   -i, --input  <body|->      Message body to inject, or - to read from stdin
- *   -d, --daemon               Keep context alive until SIGINT/SIGTERM (default: false)
- *   -l, --log-mode <text|json> Log output format: text (default) or json
- *   -v, --version              Print version
- *   -h, --help                 Print this help
+ *   -r, --routes <file|->                     Route definition file (.yaml/.yml/.json) or - for stdin
+ *   -i, --input  <body|->                     Message body to inject, or - to read from stdin
+ *   -d, --daemon                              Keep context alive until SIGINT/SIGTERM (default: false)
+ *   -l, --log-mode <text|json>                Log output format: text (default) or json
+ *       --verbose                             Enable info-level logging (default: logging suppressed)
+ *       --debug                               Enable debug-level logging (takes precedence over --verbose)
+ *   -p, --producer-uri <uri>                  Override producer URI (requires -i; default: first route from URI)
+ *       --exchange-pattern <i|InOnly|io|InOut> Exchange pattern: InOnly (fire-and-forget) or InOut (request-reply)
+ *   -c, --consumer-uri <uri>                  Poll consumer URI; implies daemon mode; mutually exclusive with -i and -p
+ *   -v, --version                             Print version
+ *   -h, --help                                Print this help
  *
  * Exactly one of -r or -i may use stdin (-).
  *
@@ -23,11 +31,17 @@
  *   cat route.yaml | camel-lite -r - -i '{"name":"world"}'
  *   camel-lite -r route.yaml -d         # daemon mode — Ctrl-C to stop
  *   camel-lite -l json -r route.yaml    # JSON log output
+ *   camel-lite --verbose -r route.yaml  # info-level logging
+ *   camel-lite --debug  -r route.yaml   # debug-level logging
+ *   camel-lite -r route.yaml -i 'hello' -p direct:ep
+ *   camel-lite -r route.yaml -i 'hello' --exchange-pattern InOut
+ *   camel-lite -r route.yaml -c timer:tick?period=1000  # poll consumer daemon
  */
 
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
 import { program } from 'commander';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -51,23 +65,6 @@ async function readStdin() {
   return chunks.join('');
 }
 
-/**
- * Configure @alt-javascript/logger for the requested output mode.
- * Must be called before any camel-lite module imports to take effect,
- * since loggers are constructed with their formatter at getLogger() call time.
- * @param {'text'|'json'} mode
- */
-async function configureLogging(mode) {
-  const { Boot } = await import('@alt-javascript/boot');
-  const { EphemeralConfig } = await import('@alt-javascript/config');
-  Boot.boot({
-    printBanner: false,
-    config: new EphemeralConfig({
-      logging: { format: mode === 'json' ? 'json' : 'text' }
-    })
-  });
-}
-
 // ---------------------------------------------------------------------------
 // CLI definition
 // ---------------------------------------------------------------------------
@@ -80,6 +77,11 @@ program
   .option('-i, --input <body|->', 'Message body to inject, or - to read from stdin')
   .option('-d, --daemon', 'Keep context alive until SIGINT/SIGTERM', false)
   .option('-l, --log-mode <text|json>', 'Log output format: text (default) or json', 'text')
+  .option('--verbose', 'Enable info-level framework logging (default: suppressed)', false)
+  .option('--debug', 'Enable debug-level framework logging (overrides --verbose)', false)
+  .option('-p, --producer-uri <uri>', 'Override producer URI (requires -i; default: first route from URI)')
+  .option('--exchange-pattern <i|InOnly|io|InOut>', 'Exchange pattern: InOnly (fire-and-forget) or InOut (request-reply)', 'InOnly')
+  .option('-c, --consumer-uri <uri>', 'Poll consumer URI; implies daemon mode; mutually exclusive with -i and -p')
   .addHelpText('after', `
 Examples:
   $ camel-lite -r route.yaml
@@ -88,6 +90,8 @@ Examples:
   $ cat route.yaml | camel-lite -r - -i '{"name":"world"}'
   $ camel-lite -r route.yaml -d
   $ camel-lite -l json -r route.yaml
+  $ camel-lite --verbose -r route.yaml
+  $ camel-lite --debug  -r route.yaml
 `);
 
 program.parse(process.argv);
@@ -110,20 +114,70 @@ if (logMode !== 'text' && logMode !== 'json') {
   fatal(`-l / --log-mode must be 'text' or 'json', got: '${logMode}'`);
 }
 
+// -c is mutually exclusive with -i and -p (check before -p requires -i)
+if (opts.consumerUri && opts.input !== undefined) {
+  fatal('-c / --consumer-uri is mutually exclusive with -i / --input');
+}
+if (opts.consumerUri && opts.producerUri) {
+  fatal('-c / --consumer-uri is mutually exclusive with -p / --producer-uri');
+}
+
+// -p requires -i
+if (opts.producerUri && opts.input === undefined) {
+  fatal('-p / --producer-uri requires -i / --input');
+}
+
+// --exchange-pattern normalization and validation
+const rawPattern = (opts.exchangePattern ?? 'InOnly').toLowerCase();
+const exchangePattern = (rawPattern === 'i' || rawPattern === 'inonly') ? 'InOnly'
+                      : (rawPattern === 'io' || rawPattern === 'inout') ? 'InOut'
+                      : null;
+if (!exchangePattern) {
+  fatal(`--exchange-pattern must be 'InOnly', 'i', 'InOut', or 'io', got: '${opts.exchangePattern}'`);
+}
+
 // ---------------------------------------------------------------------------
-// Configure logging FIRST — before any camel-lite module imports
+// Compute log level from flags
+// --debug takes precedence over --verbose; default is 'off'
 // ---------------------------------------------------------------------------
 
-await configureLogging(logMode);
+const logLevel = opts.debug ? 'debug' : (opts.verbose ? 'info' : 'off');
 
 // ---------------------------------------------------------------------------
-// Main async execution — import camel-lite modules AFTER logging is configured
+// Boot CDI layer FIRST — before any other dynamic imports
+// All config/boot imports are static since they must be available before CDI modules load
+// ---------------------------------------------------------------------------
+
+const { Boot } = await import('@alt-javascript/boot');
+const { EphemeralConfig, PropertySourceChain, ProfileConfigLoader } = await import('@alt-javascript/config');
+
+// Build the logging+banner overlay (highest priority)
+// EphemeralConfig direct key lookup: 'logging.level./' is found via object['logging.level./']
+const loggingOverlay = new EphemeralConfig({
+  'logging.level./': logLevel,
+  'logging.format': logMode === 'json' ? 'json' : 'text',
+  boot: { 'banner-mode': 'off' },
+});
+
+// Load user config from ~/.camel-lite (synchronous — no await needed)
+const userConfig = ProfileConfigLoader.load({
+  basePath: join(homedir(), '.camel-lite'),
+});
+
+// Compose: overlay wins over user config (index 0 = highest priority)
+const chainedConfig = new PropertySourceChain([loggingOverlay, userConfig]);
+
+// Boot the framework — must happen before any CDI/starter dynamic imports
+await Boot.boot({ config: chainedConfig });
+
+// ---------------------------------------------------------------------------
+// Main async execution — import camel-lite modules AFTER Boot.boot()
 // ---------------------------------------------------------------------------
 
 (async () => {
-  // Deferred imports so the log formatter is set before any getLogger() calls
+  // Deferred imports — must come after Boot.boot() so LoggerFactory is configured
   const { RouteLoader, ProducerTemplate } = await import('@alt-javascript/camel-lite-core');
-  const { CamelRuntime } = await import('../src/index.js');
+  const { CdiCamelRuntime } = await import('../src/index.js');
 
   let routeBuilder;
   let inputBody;
@@ -144,9 +198,15 @@ await configureLogging(logMode);
     inputBody = opts.input;
   }
 
-  // 3. Build context and start
-  const runtime = new CamelRuntime();
-  const ctx = await runtime.createContext(routeBuilder);
+  // 3. Build context and start — pass chainedConfig so CdiCamelRuntime forwards it to the starter
+  const runtime = new CdiCamelRuntime(routeBuilder, chainedConfig);
+  const ctx = await runtime.createContext();
+
+  // Wire polling URIs before start so CamelContext wraps them with PollingConsumerAdapter
+  if (opts.consumerUri) {
+    ctx.pollingUris = new Set([opts.consumerUri]);
+  }
+
   await runtime.start();
 
   // 4. Extract the from URI of the first route (used for ProducerTemplate injection)
@@ -160,21 +220,54 @@ await configureLogging(logMode);
   // 5. Inject input if provided
   if (inputBody !== undefined) {
     const pt = new ProducerTemplate(ctx);
-    const exchange = await pt.sendBody(fromUri, inputBody);
-    if (exchange.isFailed()) {
-      process.stderr.write(`camel-lite: route error: ${exchange.exception.message}\n`);
-      await runtime.stop();
-      process.exit(1);
+    const targetUri = opts.producerUri ?? fromUri;
+    if (exchangePattern === 'InOut') {
+      // requestBody returns the reply body value directly (not an Exchange)
+      const replyBody = await pt.requestBody(targetUri, inputBody);
+      if (replyBody !== null && replyBody !== undefined) {
+        const out = typeof replyBody === 'string' ? replyBody : JSON.stringify(replyBody);
+        process.stdout.write(out + '\n');
+      }
+    } else {
+      // InOnly: sendBody returns an Exchange
+      const exchange = await pt.sendBody(targetUri, inputBody);
+      if (exchange.isFailed()) {
+        process.stderr.write(`camel-lite: route error: ${exchange.exception.message}\n`);
+        await runtime.stop();
+        process.exit(1);
+      }
+      const resultBody = exchange.in.body;
+      if (resultBody !== null && resultBody !== undefined) {
+        const out = typeof resultBody === 'string' ? resultBody : JSON.stringify(resultBody);
+        process.stdout.write(out + '\n');
+      }
     }
-    // Print result body to stdout
-    const resultBody = exchange.in.body;
-    if (resultBody !== null && resultBody !== undefined) {
-      const out = typeof resultBody === 'string' ? resultBody : JSON.stringify(resultBody);
-      process.stdout.write(out + '\n');
+  }
+
+  // 6. Consumer daemon loop (-c flag)
+  if (opts.consumerUri) {
+    const { ConsumerTemplate } = await import('@alt-javascript/camel-lite-core');
+    const ct = new ConsumerTemplate(ctx);
+    let stopping = false;
+    const shutdown = async (signal) => {
+      stopping = true;
+      process.stderr.write(`\ncamel-lite: received ${signal}, stopping...\n`);
+      await runtime.stop();
+      process.exit(0);
+    };
+    process.on('SIGINT',  () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    while (!stopping) {
+      const body = await ct.receiveBody(opts.consumerUri, 5000);
+      if (body !== null && body !== undefined) {
+        const out = typeof body === 'string' ? body : JSON.stringify(body);
+        process.stdout.write(out + '\n');
+      }
     }
+    return; // skip the normal shutdown below
   }
 
-  // 6. Daemon mode or shutdown
+  // 7. Daemon mode or shutdown
   if (opts.daemon) {
     process.stderr.write(`camel-lite: context running (daemon mode) — press Ctrl-C to stop\n`);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alt-javascript/camel-lite-cli",
-  "version": "1.0.2",
-  "description": "Command-line runtime for camel-lite — load a route definition and send a message",
+  "version": "1.1.1",
+  "description": "Command-line runtime for camel-lite \u2014 load a route definition and send a message",
   "type": "module",
   "main": "src/index.js",
   "bin": {
@@ -16,19 +16,12 @@
   },
   "dependencies": {
     "commander": "^12.0.0",
-    "@alt-javascript/camel-lite-core": "1.0.2",
-    "@alt-javascript/camel-lite-component-amqp": "1.0.2",
-    "@alt-javascript/camel-lite-component-direct": "1.0.2",
-    "@alt-javascript/camel-lite-component-file": "1.0.2",
-    "@alt-javascript/camel-lite-component-ftp": "1.0.2",
-    "@alt-javascript/camel-lite-component-http": "1.0.2",
-    "@alt-javascript/camel-lite-component-log": "1.0.2",
-    "@alt-javascript/camel-lite-component-nosql": "1.0.2",
-    "@alt-javascript/camel-lite-component-seda": "1.0.2",
-    "@alt-javascript/camel-lite-component-sql": "1.0.2",
-    "@alt-javascript/camel-lite-component-timer": "1.0.2",
-    "@alt-javascript/camel-lite-component-cron": "1.0.2",
-    "@alt-javascript/camel-lite-component-master": "1.0.2"
+    "@alt-javascript/camel-lite-core": "1.1.1",
+    "@alt-javascript/boot": "^3.0.7",
+    "@alt-javascript/cdi": "^3.0.7",
+    "@alt-javascript/config": "^3.0.7",
+    "@alt-javascript/boot-camel-lite-starter": "1.1.1",
+    "@alt-javascript/boot-camel-lite-extras-starter": "1.1.1"
   },
   "keywords": [
     "alt-javascript",
@@ -48,8 +41,7 @@
     "url": "https://github.com/alt-javascript/camel-lite"
   },
   "contributors": [
-    "Claude (Anthropic)",
-    "Apache Camel — design inspiration and pattern source"
+    "Claude (Anthropic)"
   ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

package/src/index.js

@@ -1,53 +1,132 @@
-import { LoggerFactory } from '@alt-javascript/logger';
-import { CamelContext } from '@alt-javascript/camel-lite-core';
-import { registerAllComponents } from './components.js';
-
-const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/cli/CamelRuntime');
-
 /**
- * CamelRuntime — testable core of the CLI.
- * Separates context lifecycle and routing logic from the bin entry point.
+ * CdiCamelRuntime — CDI-backed camel-lite runtime for the CLI.
+ *
+ * Replaces the old CamelRuntime that manually registered components via
+ * components.js.  Now uses camelLiteExtrasStarter (which bundles
+ * boot-camel-lite-starter + boot-camel-lite-extras-starter) to boot a full
+ * CDI ApplicationContext with all components wired automatically.
+ *
+ * ALL imports of CDI / starter packages are performed dynamically inside
+ * boot() so that module-level LoggerFactory.getLogger() calls in those
+ * packages do not fire before the boot layer has set the log level.
+ *
+ * Public API (matches the old CamelRuntime contract expected by tests):
+ *
+ *   const runtime = new CdiCamelRuntime(routeBuilder?, config?);
+ *   // OR
+ *   const ctx = await runtime.createContext(routeBuilder);   // accepts builder at call-time too
+ *   await runtime.start();
+ *   await runtime.stop();
+ *   runtime.context   // → underlying CamelContext
+ *
+ * Named export CamelRuntime is kept as an alias for backward test compatibility.
  */
-class CamelRuntime {
-  #context = null;
+
+class CdiCamelRuntime {
+  #routeBuilder = null;
+  #config = null;
+  #applicationContext = null;
+  #camelLiteContextBean = null;
 
   /**
-   * Build a CamelContext with all bundled components registered and routes loaded.
-   * @param {import('@alt-javascript/camel-lite-core').RouteBuilder} routeBuilder
-   * @returns {Promise<CamelContext>}
+   * @param {object} [routeBuilder] - optional at construction; may also be supplied to createContext()
+   * @param {object} [config]       - optional config POJO or IConfig instance
+   */
+  constructor(routeBuilder, config) {
+    this.#routeBuilder = routeBuilder ?? null;
+    this.#config = config ?? null;
+  }
+
+  /**
+   * Boot the CDI ApplicationContext and wire the CamelContext.
+   * Accepts routeBuilder at call-time (overrides constructor arg) for
+   * backward compatibility with tests that call createContext(builder).
+   *
+   * @param {object} [routeBuilder] - optional override
+   * @returns {Promise<import('@alt-javascript/camel-lite-core').CamelContext>}
    */
   async createContext(routeBuilder) {
-    const ctx = new CamelContext();
-    await registerAllComponents(ctx);
-    ctx.addRoutes(routeBuilder);
-    this.#context = ctx;
-    return ctx;
+    if (routeBuilder) this.#routeBuilder = routeBuilder;
+    if (!this.#routeBuilder) {
+      throw new Error('CdiCamelRuntime: a routeBuilder must be supplied either to the constructor or to createContext()');
+    }
+    await this.#boot();
+    return this.context;
   }
 
   /**
-   * Start the context.
+   * Start the underlying CamelContext (idempotent if createContext already started it).
    * @returns {Promise<void>}
    */
   async start() {
-    if (!this.#context) throw new Error('CamelRuntime: call createContext() before start()');
-    log.info('CamelRuntime: starting context');
-    await this.#context.start();
+    if (!this.#applicationContext) {
+      throw new Error('CdiCamelRuntime: call createContext() before start()');
+    }
+    // The CDI ApplicationContext.start() already started CamelLiteContext.init()
+    // which fires CamelContext.start() asynchronously.  We just wait for it to
+    // be fully ready here.
+    await this.#camelLiteContextBean.ready();
   }
 
   /**
-   * Stop the context.
+   * Stop the underlying CamelContext and destroy the CDI ApplicationContext.
    * @returns {Promise<void>}
    */
   async stop() {
-    if (!this.#context) return;
-    log.info('CamelRuntime: stopping context');
-    await this.#context.stop();
+    if (!this.#applicationContext) return;
+    await this.#camelLiteContextBean.destroy();
+    // ApplicationContext does not expose a stop(); destroy() on the Camel bean is sufficient.
+    this.#applicationContext = null;
+    this.#camelLiteContextBean = null;
   }
 
+  /**
+   * The underlying CamelContext instance (available after createContext()).
+   * @returns {import('@alt-javascript/camel-lite-core').CamelContext | null}
+   */
   get context() {
-    return this.#context;
+    return this.#camelLiteContextBean?.camelContext ?? null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private boot method — ALL CDI/starter imports are dynamic here so that
+  // module-level LoggerFactory calls in those packages do not fire before the
+  // boot layer sets the log level.
+  // ---------------------------------------------------------------------------
+
+  async #boot() {
+    // Dynamic imports — must stay inside this async method
+    const { camelLiteExtrasStarter } = await import('@alt-javascript/boot-camel-lite-extras-starter');
+    const { Context, Singleton } = await import('@alt-javascript/cdi');
+
+    // Wrap the routeBuilder as a CDI singleton so RouteRegistry.applyRoutes()
+    // discovers it via the bean.configure() check.
+    const builder = this.#routeBuilder;
+    class CliRouteBuilder {
+      configure(camelContext) {
+        if (typeof builder.configure === 'function') builder.configure(camelContext);
+      }
+      getRoutes() {
+        return builder.getRoutes();
+      }
+    }
+
+    const userContext = new Context([
+      new Singleton({ Reference: CliRouteBuilder, name: 'cliRouteBuilder' }),
+    ]);
+
+    const { applicationContext } = await camelLiteExtrasStarter({
+      contexts: [userContext],
+      config: this.#config ?? {},
+    });
+
+    this.#applicationContext = applicationContext;
+    this.#camelLiteContextBean = applicationContext.get('camelLiteContext');
   }
 }
 
-export { CamelRuntime };
-export default CamelRuntime;
+// Backward-compat alias — tests import { CamelRuntime }
+const CamelRuntime = CdiCamelRuntime;
+
+export { CdiCamelRuntime, CamelRuntime };
+export default CdiCamelRuntime;

package/src/components.js

@@ -1,42 +0,0 @@
-import { LoggerFactory } from '@alt-javascript/logger';
-
-const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/cli/components');
-
-/**
- * Register all bundled camel-lite components into a CamelContext.
- *
- * Each component is wrapped in a try/catch so that a missing native dependency
- * (e.g. AMQP without a broker, FTP without basic-ftp installed) skips that
- * component with a warning rather than crashing the CLI for routes that don't
- * use it.
- *
- * @param {import('@alt-javascript/camel-lite-core').CamelContext} ctx
- */
-async function registerAllComponents(ctx) {
-  const registrations = [
-    { scheme: 'direct',  loader: () => import('@alt-javascript/camel-lite-component-direct').then(m => new m.DirectComponent()) },
-    { scheme: 'seda',    loader: () => import('@alt-javascript/camel-lite-component-seda').then(m => new m.SedaComponent()) },
-    { scheme: 'log',     loader: () => import('@alt-javascript/camel-lite-component-log').then(m => new m.LogComponent()) },
-    { scheme: 'file',    loader: () => import('@alt-javascript/camel-lite-component-file').then(m => new m.FileComponent()) },
-    { scheme: 'http',    loader: () => import('@alt-javascript/camel-lite-component-http').then(m => new m.HttpComponent()) },
-    { scheme: 'ftp',     loader: () => import('@alt-javascript/camel-lite-component-ftp').then(m => new m.FtpComponent()) },
-    { scheme: 'amqp',    loader: () => import('@alt-javascript/camel-lite-component-amqp').then(m => new m.AmqpComponent()) },
-    { scheme: 'sql',     loader: () => import('@alt-javascript/camel-lite-component-sql').then(m => new m.SqlComponent()) },
-    { scheme: 'nosql',   loader: () => import('@alt-javascript/camel-lite-component-nosql').then(m => new m.NosqlComponent()) },
-    { scheme: 'timer',   loader: () => import('@alt-javascript/camel-lite-component-timer').then(m => new m.TimerComponent()) },
-    { scheme: 'cron',    loader: () => import('@alt-javascript/camel-lite-component-cron').then(m => new m.CronComponent()) },
-    { scheme: 'master',  loader: () => import('@alt-javascript/camel-lite-component-master').then(m => new m.MasterComponent()) },
-  ];
-
-  for (const { scheme, loader } of registrations) {
-    try {
-      const component = await loader();
-      ctx.addComponent(scheme, component);
-      log.info(`Registered component: ${scheme}`);
-    } catch (err) {
-      log.warn(`Skipping component '${scheme}': ${err.message}`);
-    }
-  }
-}
-
-export { registerAllComponents };