Fetch job results if a job is finished

Signed-off-by: Lee Smet <lee.smet@hotmail.com>

src/clients/supervisor_client.rs

@@ -138,6 +138,54 @@ impl SupervisorClient {
         )))
     }
 
+    /// Synchronous variant: wait for a JSON-RPC reply via Mycelium reply_timeout, and return the inner JSON-RPC "result".
+    /// If the supervisor returns an error object, map to RpcError.
+    pub async fn call_sync(
+        &self,
+        method: &str,
+        params: Value,
+        reply_timeout_secs: u64,
+    ) -> Result<Value, SupervisorClientError> {
+        let inner = self.build_supervisor_payload(method, params);
+        let payload_b64 = Self::encode_payload(&inner)?;
+
+        let result = self
+            .mycelium
+            .push_message(&self.destination, &self.topic, &payload_b64, Some(reply_timeout_secs))
+            .await?;
+
+        // Expect an InboundMessage-like with a base64 payload containing the supervisor JSON-RPC response
+        let payload_field = if let Some(p) = result.get("payload").and_then(|v| v.as_str()) {
+            p.to_string()
+        } else if let Some(arr) = result.as_array() {
+            // Defensive: handle single-element array shape
+            if let Some(one) = arr.get(0) {
+                one.get("payload")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string())
+                    .ok_or_else(|| SupervisorClientError::InvalidResponse(format!("missing payload in result: {result}")))?
+            } else {
+                return Err(SupervisorClientError::TransportTimeout);
+            }
+        } else {
+            // No payload => no reply received within timeout (Mycelium would have returned just an id)
+            return Err(SupervisorClientError::TransportTimeout);
+        };
+
+        let raw = BASE64_STANDARD
+            .decode(payload_field.as_bytes())
+            .map_err(|e| SupervisorClientError::InvalidResponse(format!("invalid base64 payload: {e}")))?;
+        let rpc_resp: Value = serde_json::from_slice(&raw)?;
+
+        if let Some(err) = rpc_resp.get("error") {
+            return Err(SupervisorClientError::RpcError(err.to_string()));
+        }
+        let res = rpc_resp
+            .get("result")
+            .ok_or_else(|| SupervisorClientError::InvalidResponse(format!("missing result in supervisor reply: {rpc_resp}")))?;
+        Ok(res.clone())
+    }
+
     fn need_secret(&self) -> Result<&str, SupervisorClientError> {
         self.secret
             .as_deref()
@@ -257,6 +305,28 @@ impl SupervisorClient {
         self.call("job.status", json!([job_id.into()])).await
     }
 
+    /// Synchronous job.status: waits for the supervisor to reply and returns the status string.
+    /// The supervisor result may be an object with { status: "..." } or a bare string.
+    pub async fn job_status_sync(
+        &self,
+        job_id: impl Into<String>,
+        reply_timeout_secs: u64,
+    ) -> Result<String, SupervisorClientError> {
+        let res = self
+            .call_sync("job.status", json!([job_id.into()]), reply_timeout_secs)
+            .await?;
+        let status = if let Some(s) = res.get("status").and_then(|v| v.as_str()) {
+            s.to_string()
+        } else if let Some(s) = res.as_str() {
+            s.to_string()
+        } else {
+            return Err(SupervisorClientError::InvalidResponse(format!(
+                "unexpected job.status result shape: {res}"
+            )));
+        };
+        Ok(status)
+    }
+
     pub async fn job_result(
         &self,
         job_id: impl Into<String>,
@@ -264,6 +334,45 @@ impl SupervisorClient {
         self.call("job.result", json!([job_id.into()])).await
     }
 
+    /// Synchronous job.result: waits for the supervisor to reply and returns a map
+    /// containing exactly one of:
+    /// - {"success": "..."} on success
+    /// - {"error": "..."} on error reported by the runner
+    /// Some servers may return a bare string; we treat that as {"success": "<string>"}.
+    pub async fn job_result_sync(
+        &self,
+        job_id: impl Into<String>,
+        reply_timeout_secs: u64,
+    ) -> Result<std::collections::HashMap<String, String>, SupervisorClientError> {
+        let res = self
+            .call_sync("job.result", json!([job_id.into()]), reply_timeout_secs)
+            .await?;
+
+        use std::collections::HashMap;
+        let mut out: HashMap<String, String> = HashMap::new();
+
+        if let Some(obj) = res.as_object() {
+            if let Some(s) = obj.get("success").and_then(|v| v.as_str()) {
+                out.insert("success".to_string(), s.to_string());
+                return Ok(out);
+            }
+            if let Some(s) = obj.get("error").and_then(|v| v.as_str()) {
+                out.insert("error".to_string(), s.to_string());
+                return Ok(out);
+            }
+            return Err(SupervisorClientError::InvalidResponse(format!(
+                "unexpected job.result result shape: {res}"
+            )));
+        } else if let Some(s) = res.as_str() {
+            out.insert("success".to_string(), s.to_string());
+            return Ok(out);
+        }
+
+        Err(SupervisorClientError::InvalidResponse(format!(
+            "unexpected job.result result shape: {res}"
+        )))
+    }
+
     pub async fn job_stop(
         &self,
         job_id: impl Into<String>,