webterm_agent/messaging/
process_r2a_handshake.rs

1use crate::models::agent_error::AgentError;
2use tracing::error;
3use webterm_core::generated::flatbuffers_schema::handshake_v1::{
4    R2aHandshakeErrorType, R2aHandshakeRoot, R2aHandshakeRootPayload,
5};
6
7pub struct Output {
8    pub auth_nonce: String,
9}
10
11pub async fn process_r2a_handshake(message: R2aHandshakeRoot<'_>) -> Result<Output, AgentError> {
12    match message.root_payload_type() {
13        R2aHandshakeRootPayload::Success => {
14            let payload = message
15                .root_payload_as_success()
16                .ok_or(AgentError::RuntimeError(
17                    "Failed to parse success root payload".to_string(),
18                ))?;
19            let nonce = payload.relay_auth_nonce();
20
21            if let Some(nonce) = nonce {
22                Ok(Output {
23                    auth_nonce: nonce.to_string(),
24                })
25            } else {
26                Err(AgentError::RuntimeError(
27                    "Missing relay_auth_nonce".to_string(),
28                ))
29            }
30        }
31        R2aHandshakeRootPayload::Error => {
32            let payload = message
33                .root_payload_as_error()
34                .ok_or(AgentError::RuntimeError(
35                    "Failed to parse error root payload".to_string(),
36                ))?;
37            let error_message = payload.error_message();
38            let error_type = payload.error_type();
39            let message = format!("Error: {:?} ({:?})", error_message, error_type);
40            error!(message);
41            if error_type == R2aHandshakeErrorType::ErrorDeviceAlreadyExists {
42                return Err(AgentError::RelayErrorAgentAlreadyExists);
43            }
44            Err(AgentError::RuntimeError(message.to_string()))
45        }
46        _ => Err(AgentError::RuntimeError(format!(
47            "Unknown root_payload_type: {:?}",
48            message.root_payload_type()
49        ))),
50    }
51}