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/mock_runner.rs

@@ -0,0 +1,171 @@
+//! Mock Runner Binary for Testing OpenRPC Examples
+//!
+//! This is a simple mock runner that simulates an actor binary for testing
+//! the Hero Supervisor OpenRPC integration. It connects to Redis, listens for
+//! jobs using the proper Hero job queue system, and echoes the job payload.
+//!
+//! Usage:
+//! ```bash
+//! cargo run --example mock_runner -- --actor-id test_actor --db-path /tmp/test_db --redis-url redis://localhost:6379
+//! ```
+
+use std::env;
+use std::time::Duration;
+use tokio::time::sleep;
+use redis::AsyncCommands;
+use hero_supervisor::{
+    Job, JobStatus, JobError, Client, ClientBuilder
+};
+
+#[derive(Debug, Clone)]
+pub struct MockRunnerConfig {
+    pub actor_id: String,
+    pub db_path: String,
+    pub redis_url: String,
+}
+
+impl MockRunnerConfig {
+    pub fn from_args() -> Result<Self, Box<dyn std::error::Error>> {
+        let args: Vec<String> = env::args().collect();
+        
+        let mut actor_id = None;
+        let mut db_path = None;
+        let mut redis_url = None;
+        
+        let mut i = 1;
+        while i < args.len() {
+            match args[i].as_str() {
+                "--actor-id" => {
+                    if i + 1 < args.len() {
+                        actor_id = Some(args[i + 1].clone());
+                        i += 2;
+                    } else {
+                        return Err("Missing value for --actor-id".into());
+                    }
+                }
+                "--db-path" => {
+                    if i + 1 < args.len() {
+                        db_path = Some(args[i + 1].clone());
+                        i += 2;
+                    } else {
+                        return Err("Missing value for --db-path".into());
+                    }
+                }
+                "--redis-url" => {
+                    if i + 1 < args.len() {
+                        redis_url = Some(args[i + 1].clone());
+                        i += 2;
+                    } else {
+                        return Err("Missing value for --redis-url".into());
+                    }
+                }
+                _ => i += 1,
+            }
+        }
+        
+        Ok(MockRunnerConfig {
+            actor_id: actor_id.ok_or("Missing required --actor-id argument")?,
+            db_path: db_path.ok_or("Missing required --db-path argument")?,
+            redis_url: redis_url.unwrap_or_else(|| "redis://localhost:6379".to_string()),
+        })
+    }
+}
+
+pub struct MockRunner {
+    config: MockRunnerConfig,
+    client: Client,
+}
+
+impl MockRunner {
+    pub async fn new(config: MockRunnerConfig) -> Result<Self, Box<dyn std::error::Error>> {
+        let client = ClientBuilder::new()
+            .redis_url(&config.redis_url)
+            .build()
+            .await?;
+        
+        Ok(MockRunner {
+            config,
+            client,
+        })
+    }
+    
+    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
+        println!("🤖 Mock Runner '{}' starting...", self.config.actor_id);
+        println!("📂 DB Path: {}", self.config.db_path);
+        println!("🔗 Redis URL: {}", self.config.redis_url);
+        
+        // Use the proper Hero job queue key for this actor instance
+        // Format: hero:q:work:type:{job_type}:group:{group}:inst:{instance}
+        let work_queue_key = format!("hero:q:work:type:osis:group:default:inst:{}", self.config.actor_id);
+        
+        println!("👂 Listening for jobs on queue: {}", work_queue_key);
+        
+        loop {
+            // Try to pop a job ID from the work queue using the Hero protocol
+            let job_id = self.client.get_job_id(&work_queue_key).await?;
+            
+            match job_id {
+                Some(job_id) => {
+                    println!("📨 Received job ID: {}", job_id);
+                    if let Err(e) = self.process_job(&job_id).await {
+                        eprintln!("❌ Error processing job {}: {}", job_id, e);
+                        // Mark job as error
+                        if let Err(e2) = self.client.set_job_status(&job_id, JobStatus::Error).await {
+                            eprintln!("❌ Failed to set job error status: {}", e2);
+                        }
+                    }
+                }
+                None => {
+                    // No jobs available, wait a bit
+                    sleep(Duration::from_millis(100)).await;
+                }
+            }
+        }
+    }
+    
+    async fn process_job(&self, job_id: &str) -> Result<(), JobError> {
+        // Load the job from Redis using the Hero job system
+        let job = self.client.get_job(job_id).await?;
+        
+        self.process_job_internal(&self.client, job_id, &job).await
+    }
+
+    async fn process_job_internal(
+        &self,
+        client: &Client,
+        job_id: &str,
+        job: &Job,
+    ) -> Result<(), JobError> {
+        println!("🔄 Processing job {} with payload: {}", job_id, job.payload);
+        
+        // Mark job as started
+        client.set_job_status(job_id, JobStatus::Started).await?;
+        println!("🚀 Job {} marked as Started", job_id);
+        
+        // Simulate processing time
+        sleep(Duration::from_millis(500)).await;
+        
+        // Echo the payload (simulate job execution)
+        let output = format!("echo: {}", job.payload);
+        println!("📤 Output: {}", output);
+        
+        // Set the job result
+        client.set_result(job_id, &output).await?;
+        
+        println!("✅ Job {} completed successfully", job_id);
+        
+        Ok(())
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Parse command line arguments
+    let config = MockRunnerConfig::from_args()?;
+    
+    // Create and run the mock runner
+    let runner = MockRunner::new(config).await?;
+    runner.run().await?;
+    
+    Ok(())
+}