feat: simplify OpenRPC API and reorganize examples

- Simplified RunnerConfig to just name, command, and optional env
- Removed RunnerType and ProcessManagerType enums
- Removed db_path, redis_url, binary_path from config
- Made runner name also serve as queue name (no separate queue param)
- Added secret-based authentication to all runner management methods
- Created comprehensive osiris_openrpc example
- Archived old examples to _archive/
- Updated client API to match simplified supervisor interface

examples/_archive/supervisor/README.md

@@ -0,0 +1,108 @@
+# Hero Supervisor Example
+
+This example demonstrates how to configure and run the Hero Supervisor with multiple actors using a TOML configuration file.
+
+## Files
+
+- `config.toml` - Example supervisor configuration with multiple actors
+- `run_supervisor.sh` - Shell script to build and run the supervisor with the example config
+- `run_supervisor.rs` - Rust script using escargot to build and run the supervisor
+- `README.md` - This documentation file
+
+## Configuration
+
+The `config.toml` file defines:
+
+- **Redis connection**: URL for the Redis server used for job queuing
+- **Database path**: Local path for supervisor state storage
+- **Job queue key**: Redis key for the supervisor job queue
+- **Actors**: List of actor configurations with:
+  - `name`: Unique identifier for the actor
+  - `runner_type`: Type of runner ("SAL", "OSIS", "V", "Python")
+  - `binary_path`: Path to the actor binary
+  - `process_manager`: Process management type ("simple" or "tmux")
+
+## Prerequisites
+
+1. **Redis Server**: Ensure Redis is running on `localhost:6379` (or update the config)
+2. **Actor Binaries**: Build the required actor binaries referenced in the config:
+   ```bash
+   # Build SAL worker
+   cd ../../sal
+   cargo build --bin sal_worker
+   
+   # Build OSIS and system workers
+   cd ../../worker
+   cargo build --bin osis
+   cargo build --bin system
+   ```
+
+## Running the Example
+
+### Option 1: Shell Script (Recommended)
+
+```bash
+./run_supervisor.sh
+```
+
+### Option 2: Rust Script with Escargot
+
+```bash
+cargo +nightly -Zscript run_supervisor.rs
+```
+
+### Option 3: Manual Build and Run
+
+```bash
+# Build the supervisor
+cd ../../../supervisor
+cargo build --bin supervisor --features cli
+
+# Run with config
+./target/debug/supervisor --config ../baobab/examples/supervisor/config.toml
+```
+
+## Usage
+
+Once running, the supervisor will:
+
+1. Load the configuration from `config.toml`
+2. Initialize and start all configured actors
+3. Listen for jobs on the Redis queue (`hero:supervisor:jobs`)
+4. Dispatch jobs to appropriate actors based on the `runner` field
+5. Monitor actor health and status
+
+## Testing
+
+You can test the supervisor by dispatching jobs to the Redis queue:
+
+```bash
+# Using redis-cli to add a test job
+redis-cli LPUSH "hero:supervisor:jobs" '{"id":"test-123","runner":"sal_actor_1","script":"print(\"Hello from SAL actor!\")"}'
+```
+
+## Stopping
+
+Use `Ctrl+C` to gracefully shutdown the supervisor. It will:
+
+1. Stop accepting new jobs
+2. Wait for running jobs to complete
+3. Shutdown all managed actors
+4. Clean up resources
+
+## Customization
+
+Modify `config.toml` to:
+
+- Add more actors
+- Change binary paths to match your build locations
+- Update Redis connection settings
+- Configure different process managers per actor
+- Adjust database and queue settings
+
+## Troubleshooting
+
+- **Redis Connection**: Ensure Redis is running and accessible
+- **Binary Paths**: Verify all actor binary paths exist and are executable
+- **Permissions**: Ensure the supervisor has permission to create the database directory
+- **Ports**: Check that Redis port (6379) is not blocked by firewall

examples/_archive/supervisor/config.toml

@@ -0,0 +1,18 @@
+# Hero Supervisor Configuration
+# This configuration defines the Redis connection, database path, and actors to manage
+
+# Redis connection URL
+redis_url = "redis://localhost:6379"
+
+# Database path for supervisor state
+db_path = "/tmp/supervisor_example_db"
+
+# Job queue key for supervisor jobs
+job_queue_key = "hero:supervisor:jobs"
+
+# Actor configurations
+[[actors]]
+name = "sal_actor_1"
+runner_type = "SAL"
+binary_path = "cargo run /Users/timurgordon/code/git.ourworld.tf/herocode/supervisor/examples/mock_runner.rs"
+process_manager = "tmux"

examples/_archive/supervisor/run_supervisor.rs

@@ -0,0 +1,70 @@
+#!/usr/bin/env cargo +nightly -Zscript
+//! ```cargo
+//! [dependencies]
+//! escargot = "0.5"
+//! tokio = { version = "1.0", features = ["full"] }
+//! log = "0.4"
+//! env_logger = "0.10"
+//! ```
+
+use escargot::CargoBuild;
+use std::process::Command;
+use log::{info, error};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize logging
+    env_logger::init();
+    
+    info!("Building and running Hero Supervisor with example configuration");
+    
+    // Get the current directory (when running as cargo example, this is the crate root)
+    let current_dir = std::env::current_dir()?;
+    info!("Current directory: {}", current_dir.display());
+    
+    // Path to the supervisor crate (current directory when running as example)
+    let supervisor_crate_path = current_dir.clone();
+    
+    // Path to the config file (in examples/supervisor subdirectory)
+    let config_path = current_dir.join("examples/supervisor/config.toml");
+    
+    if !config_path.exists() {
+        error!("Config file not found: {}", config_path.display());
+        return Err("Config file not found".into());
+    }
+    
+    info!("Using config file: {}", config_path.display());
+    
+    // Build the supervisor binary using escargot
+    info!("Building supervisor binary...");
+    let supervisor_bin = CargoBuild::new()
+        .bin("supervisor")
+        .manifest_path(supervisor_crate_path.join("Cargo.toml"))
+        .features("cli")
+        .run()?;
+    
+    info!("Supervisor binary built successfully");
+    
+    // Run the supervisor with the config file
+    info!("Starting supervisor with config: {}", config_path.display());
+    
+    let mut cmd = Command::new(supervisor_bin.path());
+    cmd.arg("--config")
+       .arg(&config_path);
+    
+    // Add environment variables for better logging
+    cmd.env("RUST_LOG", "info");
+    
+    info!("Executing: {:?}", cmd);
+    
+    // Execute the supervisor
+    let status = cmd.status()?;
+    
+    if status.success() {
+        info!("Supervisor completed successfully");
+    } else {
+        error!("Supervisor exited with status: {}", status);
+    }
+    
+    Ok(())
+}

examples/_archive/supervisor/run_supervisor.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# Hero Supervisor Example Runner
+# This script builds and runs the supervisor binary with the example configuration
+
+set -e
+
+# Get the directory of this script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SUPERVISOR_DIR="$SCRIPT_DIR/../../../supervisor"
+CONFIG_FILE="$SCRIPT_DIR/config.toml"
+
+echo "🚀 Building and running Hero Supervisor with example configuration"
+echo "📁 Script directory: $SCRIPT_DIR"
+echo "🔧 Supervisor crate: $SUPERVISOR_DIR"
+echo "⚙️  Config file: $CONFIG_FILE"
+
+# Check if config file exists
+if [ ! -f "$CONFIG_FILE" ]; then
+    echo "❌ Config file not found: $CONFIG_FILE"
+    exit 1
+fi
+
+# Check if supervisor directory exists
+if [ ! -d "$SUPERVISOR_DIR" ]; then
+    echo "❌ Supervisor directory not found: $SUPERVISOR_DIR"
+    exit 1
+fi
+
+# Build the supervisor binary
+echo "🔨 Building supervisor binary..."
+cd "$SUPERVISOR_DIR"
+cargo build --bin supervisor --features cli
+
+# Check if build was successful
+if [ $? -ne 0 ]; then
+    echo "❌ Failed to build supervisor binary"
+    exit 1
+fi
+
+echo "✅ Supervisor binary built successfully"
+
+# Run the supervisor with the config file
+echo "🎯 Starting supervisor with config: $CONFIG_FILE"
+echo "📝 Use Ctrl+C to stop the supervisor"
+echo ""
+
+# Set environment variables for better logging
+export RUST_LOG=info
+
+# Execute the supervisor
+exec "$SUPERVISOR_DIR/target/debug/supervisor" --config "$CONFIG_FILE"