move repos into monorepo

lib/clients/supervisor/src/lib.rs

@@ -0,0 +1,695 @@
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+use serde_json;
+
+// Import types from the main supervisor crate
+
+
+// WASM-compatible client module
+#[cfg(target_arch = "wasm32")]
+pub mod wasm;
+
+// Builder module for type-safe client construction
+#[cfg(target_arch = "wasm32")]
+pub mod builder;
+
+// Re-export WASM types for convenience
+#[cfg(target_arch = "wasm32")]
+pub use wasm::{WasmSupervisorClient, WasmJobType, WasmRunnerType, create_job_canonical_repr, sign_job_canonical};
+
+// Re-export builder for convenience
+#[cfg(target_arch = "wasm32")]
+pub use builder::WasmSupervisorClientBuilder;
+
+// Native client dependencies
+#[cfg(not(target_arch = "wasm32"))]
+use jsonrpsee::{
+    core::client::ClientT,
+    http_client::{HttpClient, HttpClientBuilder},
+    rpc_params,
+};
+
+#[cfg(not(target_arch = "wasm32"))]
+use http::{HeaderMap, HeaderName, HeaderValue};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::path::PathBuf;
+
+/// Client for communicating with Hero Supervisor OpenRPC server
+/// Requires authentication secret for all operations
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Clone)]
+pub struct SupervisorClient {
+    client: HttpClient,
+    server_url: String,
+    secret: String,
+}
+
+/// Error types for client operations
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Error, Debug)]
+pub enum ClientError {
+    #[error("JSON-RPC error: {0}")]
+    JsonRpc(#[from] jsonrpsee::core::ClientError),
+    
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+    
+    #[error("HTTP client error: {0}")]
+    Http(String),
+    
+    #[error("Server error: {message}")]
+    Server { message: String },
+}
+
+/// Error types for WASM client operations
+#[cfg(target_arch = "wasm32")]
+#[derive(Error, Debug)]
+pub enum ClientError {
+    #[error("JSON-RPC error: {0}")]
+    JsonRpc(String),
+    
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+    
+    #[error("HTTP client error: {0}")]
+    Http(String),
+    
+    #[error("Server error: {message}")]
+    Server { message: String },
+    
+    #[error("JavaScript error: {0}")]
+    JavaScript(String),
+    
+    #[error("Network error: {0}")]
+    Network(String),
+}
+
+// Implement From for jsonrpsee ClientError for WASM
+#[cfg(target_arch = "wasm32")]
+impl From<wasm_bindgen::JsValue> for ClientError {
+    fn from(js_val: wasm_bindgen::JsValue) -> Self {
+        ClientError::JavaScript(format!("{:?}", js_val))
+    }
+}
+
+/// Result type for client operations
+pub type ClientResult<T> = Result<T, ClientError>;
+
+/// Request parameters for generating API keys (auto-generates key value)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GenerateApiKeyParams {
+    pub name: String,
+    pub scope: String, // "admin", "registrar", or "user"
+}
+
+/// Configuration for a runner
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RunnerConfig {
+    /// Name of the runner
+    pub name: String,
+    /// Command to run the runner (full command line)
+    pub command: String,
+    /// Optional environment variables
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub env: Option<std::collections::HashMap<String, String>>,
+}
+
+
+
+/// Job result response
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum JobResult {
+    Success { success: String },
+    Error { error: String },
+}
+
+/// Job status response
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JobStatusResponse {
+    pub job_id: String,
+    pub status: String,
+    pub created_at: String,
+    pub started_at: Option<String>,
+    pub completed_at: Option<String>,
+}
+
+/// Response from job.run (blocking execution)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JobRunResponse {
+    pub job_id: String,
+    pub status: String,
+    pub result: Option<String>,
+}
+
+/// Response from job.start (non-blocking execution)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JobStartResponse {
+    pub job_id: String,
+    pub status: String,
+}
+
+// Re-export Job types from hero-job crate (both native and WASM)
+pub use hero_job::{Job, JobStatus, JobError, JobBuilder, JobSignature};
+
+// Note: Job client is now part of hero-supervisor crate
+// Re-exports removed - use hero_supervisor::job_client directly if needed
+
+/// Process status wrapper for OpenRPC serialization (matches server response)
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum ProcessStatusWrapper {
+    Running,
+    Stopped,
+    Starting,
+    Stopping,
+    Error(String),
+}
+
+/// Log information wrapper for OpenRPC serialization (matches server response)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LogInfoWrapper {
+    pub timestamp: String,
+    pub level: String,
+    pub message: String,
+}
+
+/// Supervisor information response containing secret counts and server details
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SupervisorInfo {
+    pub server_url: String,
+}
+
+/// API Key information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ApiKey {
+    pub key: String,
+    pub name: String,
+    pub scope: String,
+    pub created_at: String,
+}
+
+/// Auth verification response
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AuthVerifyResponse {
+    pub scope: String,
+    pub name: Option<String>,
+    pub created_at: Option<String>,
+}
+
+/// Simple ProcessStatus type for native builds to avoid service manager dependency
+#[cfg(not(target_arch = "wasm32"))]
+pub type ProcessStatus = ProcessStatusWrapper;
+
+// Types duplicated from supervisor-core to avoid cyclic dependency
+// These match the types in hero-supervisor but are defined here independently
+
+/// Runner status information (duplicated to avoid cyclic dependency)
+#[cfg(not(target_arch = "wasm32"))]
+pub type RunnerStatus = ProcessStatusWrapper;
+
+/// Log information (duplicated to avoid cyclic dependency)
+#[cfg(not(target_arch = "wasm32"))]
+pub type LogInfo = LogInfoWrapper;
+
+/// Type aliases for WASM compatibility
+#[cfg(target_arch = "wasm32")]
+pub type ProcessStatus = ProcessStatusWrapper;
+#[cfg(target_arch = "wasm32")]
+pub type RunnerStatus = ProcessStatusWrapper;
+#[cfg(target_arch = "wasm32")]
+pub type LogInfo = LogInfoWrapper;
+
+/// Builder for SupervisorClient
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Debug, Clone)]
+pub struct SupervisorClientBuilder {
+    url: Option<String>,
+    secret: Option<String>,
+    timeout: Option<std::time::Duration>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl SupervisorClientBuilder {
+    /// Create a new builder
+    pub fn new() -> Self {
+        Self {
+            url: None,
+            secret: None,
+            timeout: Some(std::time::Duration::from_secs(30)),
+        }
+    }
+    
+    /// Set the server URL
+    pub fn url(mut self, url: impl Into<String>) -> Self {
+        self.url = Some(url.into());
+        self
+    }
+    
+    /// Set the authentication secret
+    pub fn secret(mut self, secret: impl Into<String>) -> Self {
+        self.secret = Some(secret.into());
+        self
+    }
+    
+    /// Set the request timeout (default: 30 seconds)
+    pub fn timeout(mut self, timeout: std::time::Duration) -> Self {
+        self.timeout = Some(timeout);
+        self
+    }
+    
+    /// Build the SupervisorClient
+    pub fn build(self) -> ClientResult<SupervisorClient> {
+        let server_url = self.url
+            .ok_or_else(|| ClientError::Http("URL is required".to_string()))?;
+        let secret = self.secret
+            .ok_or_else(|| ClientError::Http("Secret is required".to_string()))?;
+        
+        // Create headers with Authorization bearer token
+        let mut headers = HeaderMap::new();
+        let auth_value = format!("Bearer {}", secret);
+        headers.insert(
+            HeaderName::from_static("authorization"),
+            HeaderValue::from_str(&auth_value)
+                .map_err(|e| ClientError::Http(format!("Invalid auth header: {}", e)))?
+        );
+        
+        let client = HttpClientBuilder::default()
+            .request_timeout(self.timeout.unwrap_or(std::time::Duration::from_secs(30)))
+            .set_headers(headers)
+            .build(&server_url)
+            .map_err(|e| ClientError::Http(e.to_string()))?;
+        
+        Ok(SupervisorClient {
+            client,
+            server_url,
+            secret,
+        })
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Default for SupervisorClientBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl SupervisorClient {
+    /// Create a builder for SupervisorClient
+    pub fn builder() -> SupervisorClientBuilder {
+        SupervisorClientBuilder::new()
+    }
+    
+    /// Get the server URL
+    pub fn server_url(&self) -> &str {
+        &self.server_url
+    }
+    
+    /// Test connection using OpenRPC discovery method
+    /// This calls the standard `rpc.discover` method that should be available on any OpenRPC server
+    pub async fn discover(&self) -> ClientResult<serde_json::Value> {
+        let result: serde_json::Value = self
+            .client
+            .request("rpc.discover", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(result)
+    }
+    
+    /// Register a new runner to the supervisor
+    /// The runner name is also used as the queue name
+    /// Authentication via Authorization header (set during client creation)
+    pub async fn runner_create(
+        &self,
+        name: &str,
+    ) -> ClientResult<()> {
+        let _: () = self
+            .client
+            .request("runner.create", rpc_params![name])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+
+    /// Create a new job without queuing it to a runner
+    /// Authentication via Authorization header (set during client creation)
+    pub async fn job_create(
+        &self,
+        job: Job,
+    ) -> ClientResult<String> {
+        let job_id: String = self
+            .client
+            .request("job.create", rpc_params![job])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(job_id)
+    }
+
+    /// List all jobs
+    pub async fn job_list(&self) -> ClientResult<Vec<Job>> {
+        let jobs: Vec<Job> = self
+            .client
+            .request("job.list", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(jobs)
+    }
+
+    /// Run a job on the appropriate runner and wait for the result (blocking)
+    /// This method queues the job and waits for completion before returning
+    /// The secret is sent via Authorization header (set during client creation)
+    pub async fn job_run(
+        &self,
+        job: Job,
+        timeout: Option<u64>,
+    ) -> ClientResult<JobRunResponse> {
+        let mut params = serde_json::json!({
+            "job": job
+        });
+        
+        if let Some(t) = timeout {
+            params["timeout"] = serde_json::json!(t);
+        }
+        
+        let result: JobRunResponse = self
+            .client
+            .request("job.run", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(result)
+    }
+
+    /// Start a job without waiting for the result (non-blocking)
+    /// This method queues the job and returns immediately with the job_id
+    /// Authentication via Authorization header (set during client creation)
+    pub async fn job_start(
+        &self,
+        job: Job,
+    ) -> ClientResult<JobStartResponse> {
+        let params = serde_json::json!({
+            "job": job
+        });
+        
+        let result: JobStartResponse = self
+            .client
+            .request("job.start", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(result)
+    }
+
+    /// Get the current status of a job
+    pub async fn job_status(&self, job_id: &str) -> ClientResult<JobStatus> {
+        let status: JobStatus = self
+            .client
+            .request("job.status", rpc_params![job_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(status)
+    }
+
+    /// Get the result of a completed job (blocks until result is available)
+    pub async fn job_result(&self, job_id: &str) -> ClientResult<JobResult> {
+        let result: JobResult = self
+            .client
+            .request("job.result", rpc_params![job_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(result)
+    }
+    
+    /// Remove a runner from the supervisor
+    /// Authentication via Authorization header (set during client creation)
+    pub async fn runner_remove(&self, runner_id: &str) -> ClientResult<()> {
+        let _: () = self
+            .client
+            .request("runner.remove", rpc_params![runner_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+    
+    /// List all runner IDs
+    pub async fn runner_list(&self) -> ClientResult<Vec<String>> {
+        let runners: Vec<String> = self
+            .client
+            .request("runner.list", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(runners)
+    }
+    
+    /// Start a specific runner
+    /// Authentication via Authorization header (set during client creation)
+    pub async fn start_runner(&self, actor_id: &str) -> ClientResult<()> {
+        let _: () = self
+            .client
+            .request("runner.start", rpc_params![actor_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+
+    /// Add a runner to the supervisor
+    /// Authentication via Authorization header (set during client creation)
+    pub async fn add_runner(&self, config: RunnerConfig) -> ClientResult<()> {
+        let params = serde_json::json!({
+            "config": config
+        });
+        let _: () = self
+            .client
+            .request("runner.add", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+    
+    /// Get status of a specific runner
+    /// Authentication via Authorization header (set during client creation)
+    pub async fn get_runner_status(&self, actor_id: &str) -> ClientResult<RunnerStatus> {
+        let status: RunnerStatus = self
+            .client
+            .request("runner.status", rpc_params![actor_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(status)
+    }
+    
+    /// Get logs for a specific runner
+    pub async fn get_runner_logs(
+        &self,
+        actor_id: &str,
+        lines: Option<usize>,
+        follow: bool,
+    ) -> ClientResult<Vec<LogInfo>> {
+        let logs: Vec<LogInfo> = self
+            .client
+            .request("get_runner_logs", rpc_params![actor_id, lines, follow])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(logs)
+    }
+    
+    /// Queue a job to a specific runner
+    pub async fn queue_job_to_runner(&self, runner: &str, job: Job) -> ClientResult<()> {
+        let params = serde_json::json!({
+            "runner": runner,
+            "job": job
+        });
+        
+        let _: () = self
+            .client
+            .request("queue_job_to_runner", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+    
+    /// Queue a job and wait for completion
+    pub async fn queue_and_wait(&self, runner: &str, job: Job, timeout_secs: u64) -> ClientResult<Option<String>> {
+        let params = serde_json::json!({
+            "runner": runner,
+            "job": job,
+            "timeout_secs": timeout_secs
+        });
+        
+        let result: Option<String> = self
+            .client
+            .request("queue_and_wait", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(result)
+    }
+
+    /// Run a job on a specific runner
+    pub async fn run_job(&self, job: Job) -> ClientResult<JobResult> {
+        let params = serde_json::json!({
+            "job": job
+        });
+        
+        let result: JobResult = self
+            .client
+            .request("job.run", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(result)
+    }
+    
+    /// Get job result by job ID
+    pub async fn get_job_result(&self, job_id: &str) -> ClientResult<Option<String>> {
+        let result: Option<String> = self
+            .client
+            .request("get_job_result", rpc_params![job_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(result)
+    }
+    
+    /// Get status of all runners
+    pub async fn get_all_runner_status(&self) -> ClientResult<Vec<(String, RunnerStatus)>> {
+        let statuses: Vec<(String, RunnerStatus)> = self
+            .client
+            .request("get_all_runner_status", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(statuses)
+    }
+    
+    /// Start all runners
+    pub async fn start_all(&self) -> ClientResult<Vec<(String, bool)>> {
+        let results: Vec<(String, bool)> = self
+            .client
+            .request("start_all", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(results)
+    }
+    
+    /// Stop all runners
+    pub async fn stop_all(&self, force: bool) -> ClientResult<Vec<(String, bool)>> {
+        let results: Vec<(String, bool)> = self
+            .client
+            .request("stop_all", rpc_params![force])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(results)
+    }
+    
+    /// Get status of all runners (alternative method)
+    pub async fn get_all_status(&self) -> ClientResult<Vec<(String, RunnerStatus)>> {
+        let statuses: Vec<(String, RunnerStatus)> = self
+            .client
+            .request("get_all_status", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(statuses)
+    }
+
+    /// Add a secret to the supervisor
+    pub async fn add_secret(
+        &self,
+        secret_type: &str,
+        secret_value: &str,
+    ) -> ClientResult<()> {
+        let params = serde_json::json!({
+            "secret_type": secret_type,
+            "secret_value": secret_value
+        });
+        
+        let _: () = self
+            .client
+            .request("add_secret", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+
+    /// Remove a secret from the supervisor
+    pub async fn remove_secret(
+        &self,
+        secret_type: &str,
+        secret_value: &str,
+    ) -> ClientResult<()> {
+        let params = serde_json::json!({
+            "secret_type": secret_type,
+            "secret_value": secret_value
+        });
+        
+        let _: () = self
+            .client
+            .request("remove_secret", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+
+    /// List secrets (returns supervisor info including secret counts)
+    pub async fn list_secrets(&self) -> ClientResult<SupervisorInfo> {
+        let params = serde_json::json!({});
+        
+        let info: SupervisorInfo = self
+            .client
+            .request("list_secrets", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(info)
+    }
+
+    /// Stop a running job
+    pub async fn job_stop(&self, job_id: &str) -> ClientResult<()> {
+        let _: () = self.client
+            .request("job.stop", rpc_params![job_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+
+    /// Delete a job from the system
+    pub async fn job_delete(&self, job_id: &str) -> ClientResult<()> {
+        let _: () = self.client
+            .request("job.delete", rpc_params![job_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+
+    /// Get supervisor information including secret counts
+    pub async fn get_supervisor_info(&self) -> ClientResult<SupervisorInfo> {
+        let info: SupervisorInfo = self
+            .client
+            .request("supervisor.info", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(info)
+    }
+    
+    /// Get a job by ID
+    pub async fn job_get(&self, job_id: &str) -> ClientResult<Job> {
+        let job: Job = self
+            .client
+            .request("job.get", rpc_params![job_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(job)
+    }
+    
+    // ========== Auth/API Key Methods ==========
+    
+    /// Verify the current API key
+    pub async fn auth_verify(&self) -> ClientResult<AuthVerifyResponse> {
+        let response: AuthVerifyResponse = self
+            .client
+            .request("auth.verify", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(response)
+    }
+    
+    /// Create a new API key (admin only)
+    pub async fn key_create(&self, key: ApiKey) -> ClientResult<()> {
+        let _: () = self
+            .client
+            .request("key.create", rpc_params![key])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+    
+    /// Generate a new API key with auto-generated key value (admin only)
+    pub async fn key_generate(&self, params: GenerateApiKeyParams) -> ClientResult<ApiKey> {
+        let api_key: ApiKey = self
+            .client
+            .request("key.generate", rpc_params![params])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(api_key)
+    }
+    
+    /// Remove an API key (admin only)
+    pub async fn key_delete(&self, key_id: String) -> ClientResult<()> {
+        let _: () = self
+            .client
+            .request("key.delete", rpc_params![key_id])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(())
+    }
+    
+    /// List all API keys (admin only)
+    pub async fn key_list(&self) -> ClientResult<Vec<ApiKey>> {
+        let keys: Vec<ApiKey> = self
+            .client
+            .request("key.list", rpc_params![])
+            .await.map_err(|e| ClientError::JsonRpc(e))?;
+        Ok(keys)
+    }
+}