@alt-javascript/camel-lite-cli 1.0.2

package/README.md

@@ -0,0 +1,52 @@
+# 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.
+
+## Install
+
+```sh
+npm install -g camel-lite-cli
+```
+
+## Usage
+
+```sh
+# Run a route file (daemon mode implied — exits when the route finishes)
+camel-lite -r route.yaml
+
+# Inject a JSON body and exit
+camel-lite -r route.yaml -i '{"name":"world"}'
+
+# Read the message body from stdin
+camel-lite -r route.yaml -i -
+
+# Read the route definition from stdin, inject a literal string body
+cat route.yaml | camel-lite -r - -i body
+
+# Daemon mode — keep running after the initial message (timer/cron/seda routes)
+camel-lite -r route.yaml -d
+
+# JSON-structured log output
+camel-lite -l json -r route.yaml
+```
+
+## Options
+
+| 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 | — |
+
+## Notes
+
+- 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).
+
+## See Also
+
+- [camel-lite root README](../../README.md)

package/bin/camel-lite.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+
+/**
+ * camel-lite CLI
+ *
+ * Usage:
+ *   camel-lite -r <route-file|->  [-i <input|->]  [-d]  [-l text|json]
+ *
+ * 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
+ *
+ * Exactly one of -r or -i may use stdin (-).
+ *
+ * Examples:
+ *   camel-lite -r route.yaml
+ *   camel-lite -r route.yaml -i '{"name":"world"}'
+ *   camel-lite -r route.yaml -i -       # read body from stdin
+ *   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
+ */
+
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { program } from 'commander';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function fatal(msg) {
+  process.stderr.write(`camel-lite: error: ${msg}\n`);
+  process.exit(1);
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+  }
+  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
+// ---------------------------------------------------------------------------
+
+program
+  .name('camel-lite')
+  .version(pkg.version, '-v, --version')
+  .description('Load a camel-lite route definition and optionally inject a message')
+  .option('-r, --routes <file|->', 'Route definition file (.yaml/.yml/.json) or - for stdin')
+  .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')
+  .addHelpText('after', `
+Examples:
+  $ camel-lite -r route.yaml
+  $ camel-lite -r route.yaml -i '{"name":"world"}'
+  $ camel-lite -r route.yaml -i -
+  $ cat route.yaml | camel-lite -r - -i '{"name":"world"}'
+  $ camel-lite -r route.yaml -d
+  $ camel-lite -l json -r route.yaml
+`);
+
+program.parse(process.argv);
+const opts = program.opts();
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+if (!opts.routes) {
+  fatal('-r / --routes is required');
+}
+
+if (opts.routes === '-' && opts.input === '-') {
+  fatal('-r - and -i - are mutually exclusive: only one argument can read from stdin');
+}
+
+const logMode = (opts.logMode ?? 'text').toLowerCase();
+if (logMode !== 'text' && logMode !== 'json') {
+  fatal(`-l / --log-mode must be 'text' or 'json', got: '${logMode}'`);
+}
+
+// ---------------------------------------------------------------------------
+// Configure logging FIRST — before any camel-lite module imports
+// ---------------------------------------------------------------------------
+
+await configureLogging(logMode);
+
+// ---------------------------------------------------------------------------
+// Main async execution — import camel-lite modules AFTER logging is configured
+// ---------------------------------------------------------------------------
+
+(async () => {
+  // Deferred imports so the log formatter is set before any getLogger() calls
+  const { RouteLoader, ProducerTemplate } = await import('@alt-javascript/camel-lite-core');
+  const { CamelRuntime } = await import('../src/index.js');
+
+  let routeBuilder;
+  let inputBody;
+
+  // 1. Load route definition
+  if (opts.routes === '-') {
+    process.stderr.write('camel-lite: reading route definition from stdin...\n');
+    routeBuilder = await RouteLoader.loadStream(process.stdin);
+  } else {
+    routeBuilder = await RouteLoader.loadFile(opts.routes);
+  }
+
+  // 2. Read input body if -i - (stdin, only reachable when -r was not -)
+  if (opts.input === '-') {
+    process.stderr.write('camel-lite: reading input body from stdin...\n');
+    inputBody = await readStdin();
+  } else if (opts.input !== undefined) {
+    inputBody = opts.input;
+  }
+
+  // 3. Build context and start
+  const runtime = new CamelRuntime();
+  const ctx = await runtime.createContext(routeBuilder);
+  await runtime.start();
+
+  // 4. Extract the from URI of the first route (used for ProducerTemplate injection)
+  const routes = routeBuilder.getRoutes();
+  if (routes.length === 0) {
+    await runtime.stop();
+    fatal('No routes found in the route definition');
+  }
+  const fromUri = routes[0].fromUri;
+
+  // 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);
+    }
+    // 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. Daemon mode or shutdown
+  if (opts.daemon) {
+    process.stderr.write(`camel-lite: context running (daemon mode) — press Ctrl-C to stop\n`);
+
+    const shutdown = async (signal) => {
+      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'));
+  } else {
+    await runtime.stop();
+    process.exit(0);
+  }
+})().catch(err => {
+  process.stderr.write(`camel-lite: fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,58 @@
+{
+  "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",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "camel-lite": "./bin/camel-lite.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "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"
+  },
+  "keywords": [
+    "alt-javascript",
+    "camel",
+    "camel-lite",
+    "eai",
+    "eip",
+    "integration",
+    "cli",
+    "routing",
+    "yaml"
+  ],
+  "author": "Craig Parravicini",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alt-javascript/camel-lite"
+  },
+  "contributors": [
+    "Claude (Anthropic)",
+    "Apache Camel — design inspiration and pattern source"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/components.js

@@ -0,0 +1,42 @@
+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 };

package/src/index.js

@@ -0,0 +1,53 @@
+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.
+ */
+class CamelRuntime {
+  #context = null;
+
+  /**
+   * Build a CamelContext with all bundled components registered and routes loaded.
+   * @param {import('@alt-javascript/camel-lite-core').RouteBuilder} routeBuilder
+   * @returns {Promise<CamelContext>}
+   */
+  async createContext(routeBuilder) {
+    const ctx = new CamelContext();
+    await registerAllComponents(ctx);
+    ctx.addRoutes(routeBuilder);
+    this.#context = ctx;
+    return ctx;
+  }
+
+  /**
+   * Start the context.
+   * @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();
+  }
+
+  /**
+   * Stop the context.
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    if (!this.#context) return;
+    log.info('CamelRuntime: stopping context');
+    await this.#context.stop();
+  }
+
+  get context() {
+    return this.#context;
+  }
+}
+
+export { CamelRuntime };
+export default CamelRuntime;