Name	Name	Last commit message	Last commit date
parent directory ..
src	src
CHANGELOG.md	CHANGELOG.md
CLAUDE.md	CLAUDE.md
Cargo.toml	Cargo.toml
Dockerfile	Dockerfile
LICENSE	LICENSE
README.md	README.md
build.rs	build.rs
docker-compose.yml	docker-compose.yml

Orion

The command-line interface for Orion — manage workflows, channels, connectors, plugins, schedules, and data pipelines from your terminal.

Create, test, and deploy workflows. Define channels as service endpoints. Send data through channels. Monitor engine health and metrics. Pair it with the Orion agent skill to let an AI assistant drive the same commands.

Quick Start

orion-cli creating and activating a workflow, dry-running it, then sending live data

Create, activate, dry-run and send — the full lifecycle from one terminal.

1. Install the CLI:

brew install GoPlasmatic/tap/orion-cli   # or: curl installer, Docker (see Install)

2. Point it at your Orion server:

orion-cli config set-server http://localhost:8080

3. Check the server is running:

orion-cli health

Orion Server v1.0.0
  Status:       OK
  Uptime:       2h 30m
  Components:
    database     OK
    engine       OK

4. Create a workflow and channel, test it, send data:

# Create a workflow from a JSON file
orion-cli workflows create -f high-value-order.json

# Activate it
orion-cli workflows activate <WORKFLOW_ID>

# Create a channel that links to the workflow
orion-cli channels create -d '{"name":"orders","channel_type":"sync","protocol":"http","route_pattern":"/orders","methods":["POST"],"workflow_id":"<WORKFLOW_ID>"}'
orion-cli channels activate <CHANNEL_ID>

# Activation hot-reloads the engine on its own — no reload step needed

# Dry-run test with sample data
orion-cli workflows test <WORKFLOW_ID> -d '{"order_id":"ORD-9182","total":25000}' --trace

# Send real data through the channel
orion-cli send orders -d '{"order_id":"ORD-9182","total":25000}'

Commands

Command	Description
`health`	Check server health and component status
`benchmark`	Load-test a channel and report latency statistics
`workflows`	Manage workflows — create, update, delete, test, import/export, diff
`channels`	Manage channels — create, update, delete, activate/archive, versioning, bulk import
`connectors`	Manage connectors — create, update, delete, enable/disable, circuit breakers, bulk import
`plugins`	Manage WebAssembly plugins — create from a manifest, activate/archive, versioning, dependencies, import/export
`models`	Manage ONNX models — register a manifest plus an object-storage reference, follow admission with `--wait`, activate/archive, versioning, dependencies, import/export
`cron`	The scheduled-run ledger — status, list, get, retry or cancel an occurrence
`send`	Send data through channels (sync or async; `--profile` for timing breakdown)
`traces`	View and monitor execution traces
`engine`	View engine status and trigger reloads
`functions`	Inspect workflow task functions registered in the engine
`metrics`	Retrieve Prometheus metrics
`audit-logs`	View audit logs of admin actions
`backups`	Create and list database backups (SQLite)
`packages`	List and inspect package promotion receipts
`dlq`	Inspect and requeue the trace dead-letter queue
`config`	Configure server URL and defaults
`completions`	Generate shell completions (bash, zsh, fish, powershell)

Global Flags

--server <URL>      Orion server URL (overrides config; env: ORION_SERVER_URL)
--output <FORMAT>   Output format: table, json, yaml (default: table)
--quiet             Suppress output, print only IDs or minimal info
--verbose           Show full response bodies and extra details
--no-color          Disable colored output (env: NO_COLOR)
--yes               Skip confirmation prompts

Workflow Management

Full lifecycle management for Orion workflows:

# List workflows with filters
orion-cli workflows list --status active --tag fraud

# Get full workflow details
orion-cli workflows get <ID>

# Create from file or inline JSON
orion-cli workflows create -f workflow.json
orion-cli workflows create -d '{"name":"My Workflow",...}'

# Create with a custom ID
orion-cli workflows create --id my-custom-id -f workflow.json

# Update a workflow (version auto-increments)
orion-cli workflows update <ID> -f updated-workflow.json

# Change workflow status
orion-cli workflows activate <ID>
orion-cli workflows archive <ID>

# Control rollout percentage
orion-cli workflows rollout <ID> -p 50

# Delete (with confirmation prompt)
orion-cli workflows delete <ID>

Dry-Run Testing

Test any workflow against sample data before activating — with a full execution trace:

orion-cli workflows test <ID> -d '{"order_id":"ORD-9182","total":25000}' --trace

Result: MATCHED

Trace:
  parse    executed
  flag     executed

Output:
  {
    "order": {
      "order_id": "ORD-9182",
      "total": 25000,
      "flagged": true,
      "alert": "High-value order: $25000"
    }
  }

Supports input from file (-f), inline JSON (-d), or stdin (--stdin).

Import, Export & Diff

GitOps-ready workflows for CI/CD pipelines:

# Export workflows (with optional filters)
orion-cli workflows export --status active > workflows.json

# Import workflows from file
orion-cli workflows import -f workflows.json

# Validate the import on the server without applying (reports would_create/would_fail)
orion-cli workflows import -f workflows.json --dry-run

# Compare local file against server state
orion-cli workflows diff -f workflows.json

The diff command shows color-coded changes: + new, ~ modified, = unchanged, - deleted.

Channel Management

Channels are service endpoints that receive data and route it to workflows:

# List channels
orion-cli channels list --status active --protocol rest

# Create a channel
orion-cli channels create -d '{"name":"orders","channel_type":"sync","protocol":"rest","route_pattern":"/orders/{id}","methods":["GET"],"workflow_id":"process-orders"}'

# Activate / Archive
orion-cli channels activate <ID>
orion-cli channels archive <ID>

# Version management
orion-cli channels versions <ID>
orion-cli channels new-version <ID>

# Bulk import (server-side validation with --dry-run)
orion-cli channels import -f channels.json --dry-run
orion-cli channels import -f channels.json

Connectors

Manage named external service configurations with auth and retry policies:

orion-cli connectors list
orion-cli connectors get <ID>
orion-cli connectors create -f connector.json
orion-cli connectors update <ID> -f connector.json
orion-cli connectors delete <ID>
orion-cli connectors enable <ID>
orion-cli connectors disable <ID>

# Circuit breaker management
orion-cli connectors circuit-breakers
orion-cli connectors reset-breaker <KEY>

# Bulk import (server-side validation with --dry-run)
orion-cli connectors import -f connectors.json --dry-run
orion-cli connectors import -f connectors.json

Sending Data

Processing modes for any workload:

Synchronous (default)

orion-cli send orders -d '{"order_id":"ORD-001","amount":150}'

# Include a server-side execution profile (timing breakdown by phase/handler).
# Requires tracing.debug_profile_enabled on the server.
orion-cli send orders -d '{"order_id":"ORD-001","amount":150}' --profile

Asynchronous

# Fire and forget — returns trace_id
orion-cli send orders --async-mode -d '{"amount":100}'

# Submit and wait for completion
orion-cli send orders --async-mode --wait --timeout 30 -d '{"amount":100}'

Plugins

A plugin adds a custom task function as a sandboxed WebAssembly component. It is a versioned entity, so it follows the same draft → activate path:

orion-cli plugins create -f plugin.toml     # the component is read beside it
orion-cli plugins activate <ID>
orion-cli plugins dependencies <ID>         # what would break on archive
orion-cli plugins export --include-artifacts -o plugins.json

Activate a plugin before the workflows that call its functions. The server needs plugins.enabled = true, and --signature where it configures [plugins.trust].

Models

A model is an ONNX artifact whose bytes live in an S3-compatible bucket behind a storage connector; Orion stores only a reference — connector, object key, sha256 digest — and admits each version asynchronously (fetch, verify the digest, parse the graph, one probe inference) before it may be activated:

orion-cli models create -f model.json --connector models-bucket \
    --key fraud/v3.onnx --digest sha256:9f1c... --wait   # follow admission
orion-cli models get <ID>                                # the verdict, and this node's residency
orion-cli models admit <ID> --wait                       # run admission again
orion-cli models list --admission failed
orion-cli models activate <ID>
orion-cli models dependencies <ID>                       # what would break on archive
orion-cli models export --status active > models.json    # the reference, never the bytes

--wait exits 0 when admission passes, 1 when it fails (printing the stage and reason) and 2 when --timeout elapses first. The server needs models.enabled = true, and --signature where it configures [models.trust].

Scheduled runs

A protocol: "cron" channel has no caller, so send cannot reach it. Its runs land in a durable occurrence ledger:

orion-cli cron status                      # what is scheduled, next fire, last result
orion-cli cron list --status failed
orion-cli cron get <OCCURRENCE_ID>
orion-cli cron retry <OCCURRENCE_ID>       # same occurrence, same scheduled_for
orion-cli cron cancel <OCCURRENCE_ID>      # stop one that has not finished, free its slot
orion-cli channels trigger <CHANNEL_ID>    # a new manual occurrence, now

Traces

View and monitor execution traces:

# Check trace status
orion-cli traces get <TRACE_ID>

# Poll until complete (with timeout)
orion-cli traces wait <TRACE_ID> --interval 2 --timeout 60

Exit codes: 0 completed, 1 failed, 2 timeout.

Engine Control

# View engine status — version, uptime, workflow counts, channels
orion-cli engine status

# Hot-reload workflows, channels and plugins (zero downtime)
orion-cli engine reload

Functions

Inspect the workflow task functions registered in the engine, with their input schemas:

# List functions (table view)
orion-cli functions list

# Full input schemas as JSON
orion-cli --output json functions list

AI Assistants

Install the Orion agent skill and an AI coding agent can drive every command below — authoring workflow JSON, dry-running it, and walking the draft → test → activate path on its own.

mkdir -p .claude/skills && cp -r skills/orion .claude/skills/

The skill is knowledge, not a service: the agent acts through this CLI under your shell, so it inherits exactly your access, every admin write lands in the audit log under your principal, and nothing new listens on a port.

Agent Skill Setup covers the machine-wide install, what the skill knows, and how to give an agent its own scoped credentials. For an assistant with no shell, the prompt pack drives the plain REST API instead.

Removed in 1.2.0: orion-cli mcp serve. Its HTTP transport put the full admin API on a port with no authentication of its own, and every one of its tools mirrored a command this CLI already had. The agent skill covers the same ground with a smaller attack surface.

Output Formats

All commands support three output formats:

orion-cli --output table workflows list    # Pretty tables (default)
orion-cli --output json  workflows list    # JSON for scripting
orion-cli --output yaml  workflows list    # YAML for config files

Use --quiet for minimal output (just IDs) — ideal for shell scripts:

WF_ID=$(orion-cli --quiet workflows create -f workflow.json)
orion-cli workflows test "$WF_ID" -d '{"amount":100}'

Configuration

Configuration is stored in ~/.orion/config.toml:

server_url = "http://localhost:8080"
default_output = "table"

orion-cli config set-server http://localhost:8080
orion-cli config set default_output json
orion-cli config show

Precedence (highest to lowest):

Command-line flags (--server, --output)
Environment variables (ORION_SERVER_URL, NO_COLOR)
Config file (~/.orion/config.toml)

Shell Completions

# Bash
orion-cli completions bash > ~/.bash_completions/orion-cli

# Zsh
orion-cli completions zsh > ~/.zfunctions/_orion-cli

# Fish
orion-cli completions fish > ~/.config/fish/completions/orion-cli.fish

Install

# Docker
docker run --rm ghcr.io/goplasmatic/orion-cli:latest --server http://host.docker.internal:8080 health

# macOS (Homebrew)
brew install GoPlasmatic/tap/orion-cli

# macOS / Linux / Windows installers: shell and PowerShell one-liners are
# attached to each orion-cli-v* release:
# https://github.com/GoPlasmatic/Orion/releases

# From source
cargo install --git https://github.com/GoPlasmatic/Orion orion-cli

Verify with orion-cli --version. Requires Rust 1.98+ for source builds.

Orion Server — The services runtime platform
API Reference — Full REST API documentation
Connectors Guide — Auth schemes, retry policies, and secrets
Production Features — Custom IDs, versioning, fault tolerance
Use Cases & Patterns — Real-world examples and AI prompt templates
Observability — Prometheus metrics, health checks, logging

Contributing

Contributions are welcome! Please open an issue or submit a pull request on GitHub.

cargo build          # Build
cargo test           # Run tests
cargo clippy         # Lint
cargo fmt            # Format

License

Apache-2.0 — see LICENSE for details.

If Orion CLI is useful to you, a ⭐ on GitHub helps other developers find it.

Navigation Menu

Repository navigation

orion-cli

orion-cli

README.md

Orion

Quick Start

Commands

Global Flags

Workflow Management

Dry-Run Testing

Import, Export & Diff

Channel Management

Connectors

Sending Data

Synchronous (default)

Asynchronous

Plugins

Models

Scheduled runs

Traces

Engine Control

Functions

AI Assistants

Output Formats

Configuration

Shell Completions

Install

Related

Contributing

License

FilesExpand file tree

orion-cli

Directory actions

More options

Directory actions

More options

Latest commit

History

orion-cli

Folders and files

parent directory

README.md

Orion

Quick Start

Commands

Global Flags

Workflow Management

Dry-Run Testing

Import, Export & Diff

Channel Management

Connectors

Sending Data

Synchronous (default)

Asynchronous

Plugins

Models

Scheduled runs

Traces

Engine Control

Functions

AI Assistants

Output Formats

Configuration

Shell Completions

Install

Related

Contributing

License