mur_core/remote/

relay.rs

//! mur.run relay-based remote execution via WebSocket tunnel.
//!
//! Routes commands through the mur.run relay server, enabling
//! execution on machines behind NAT/firewalls without direct SSH access.

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use super::{RemoteExecutor, RemoteOutput};

/// Configuration for connecting to the mur.run relay.
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct RelayConfig {
    /// WebSocket URL of the relay server.
    pub relay_url: String,
    /// Authentication token for the relay.
    pub auth_token: String,
    /// Channel/room ID for this team's machines.
    pub channel_id: String,
}

impl RelayConfig {
    /// Create a config for the default mur.run relay.
    pub fn default_relay(auth_token: String, channel_id: String) -> Self {
        Self {
            relay_url: "wss://relay.mur.run/v1/ws".to_string(),
            auth_token,
            channel_id,
        }
    }
}

/// Message sent through the relay to execute a command.
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct RelayCommand {
    pub target_machine: String,
    pub command: String,
    pub working_dir: Option<String>,
    pub timeout_secs: u64,
}

/// Response received from a relay command execution.
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct RelayResponse {
    pub machine_id: String,
    pub stdout: String,
    pub stderr: String,
    pub exit_code: i32,
    pub duration_ms: u64,
}

impl From<RelayResponse> for RemoteOutput {
    fn from(resp: RelayResponse) -> Self {
        RemoteOutput {
            stdout: resp.stdout,
            stderr: resp.stderr,
            exit_code: resp.exit_code,
            duration_ms: resp.duration_ms,
            machine_id: resp.machine_id,
        }
    }
}

/// Relay-based remote executor that tunnels through mur.run.
#[derive(Debug, Clone)]
pub struct RelayExecutor {
    config: RelayConfig,
    /// Default timeout for remote commands in seconds.
    default_timeout_secs: u64,
}

impl RelayExecutor {
    /// Create a new relay executor.
    pub fn new(config: RelayConfig) -> Self {
        Self {
            config,
            default_timeout_secs: 300,
        }
    }

    /// Set the default command timeout.
    pub fn with_timeout(mut self, timeout_secs: u64) -> Self {
        self.default_timeout_secs = timeout_secs;
        self
    }

    /// Get the relay URL.
    pub fn relay_url(&self) -> &str {
        &self.config.relay_url
    }

    /// Get the channel ID.
    pub fn channel_id(&self) -> &str {
        &self.config.channel_id
    }

    /// Build a relay command message.
    pub fn build_command(
        &self,
        machine_id: &str,
        command: &str,
        working_dir: Option<&str>,
    ) -> RelayCommand {
        RelayCommand {
            target_machine: machine_id.to_string(),
            command: command.to_string(),
            working_dir: working_dir.map(String::from),
            timeout_secs: self.default_timeout_secs,
        }
    }

    /// Serialize a relay command to JSON for sending over WebSocket.
    pub fn serialize_command(&self, cmd: &RelayCommand) -> anyhow::Result<String> {
        serde_json::to_string(cmd).map_err(|e| anyhow::anyhow!("failed to serialize command: {e}"))
    }

    /// Parse a relay response from JSON received over WebSocket.
    pub fn parse_response(&self, json: &str) -> anyhow::Result<RelayResponse> {
        serde_json::from_str(json)
            .map_err(|e| anyhow::anyhow!("failed to parse relay response: {e}"))
    }
}

impl RemoteExecutor for RelayExecutor {
    fn execute(
        &self,
        machine_id: &str,
        command: &str,
        working_dir: Option<&str>,
    ) -> anyhow::Result<RemoteOutput> {
        let relay_cmd = self.build_command(machine_id, command, working_dir);
        tracing::info!(
            machine = machine_id,
            relay = %self.config.relay_url,
            "executing command via relay"
        );

        // In a full implementation, this would:
        // 1. Open a WebSocket connection to the relay
        // 2. Send the serialized command
        // 3. Wait for the response
        // For now, return an error indicating async runtime is needed
        let _serialized = self.serialize_command(&relay_cmd)?;

        anyhow::bail!(
            "relay execution requires async runtime — use async execute method or tokio::block_in_place"
        )
    }

    fn ping(&self, machine_id: &str) -> anyhow::Result<bool> {
        let cmd = self.build_command(machine_id, "echo pong", None);
        let _serialized = self.serialize_command(&cmd)?;

        // Would send via WebSocket and check response
        tracing::debug!(machine = machine_id, "relay ping (stub)");
        Ok(false)
    }

    fn executor_type(&self) -> &str {
        "relay"
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_config() -> RelayConfig {
        RelayConfig {
            relay_url: "wss://relay.mur.run/v1/ws".into(),
            auth_token: "test-token".into(),
            channel_id: "team-123".into(),
        }
    }

    #[test]
    fn test_relay_config_default() {
        let config = RelayConfig::default_relay("token".into(), "channel".into());
        assert_eq!(config.relay_url, "wss://relay.mur.run/v1/ws");
        assert_eq!(config.auth_token, "token");
        assert_eq!(config.channel_id, "channel");
    }

    #[test]
    fn test_relay_executor_new() {
        let executor = RelayExecutor::new(make_config());
        assert_eq!(executor.relay_url(), "wss://relay.mur.run/v1/ws");
        assert_eq!(executor.channel_id(), "team-123");
        assert_eq!(executor.default_timeout_secs, 300);
    }

    #[test]
    fn test_relay_executor_with_timeout() {
        let executor = RelayExecutor::new(make_config()).with_timeout(60);
        assert_eq!(executor.default_timeout_secs, 60);
    }

    #[test]
    fn test_build_command() {
        let executor = RelayExecutor::new(make_config());
        let cmd = executor.build_command("m1", "cargo build", Some("/app"));
        assert_eq!(cmd.target_machine, "m1");
        assert_eq!(cmd.command, "cargo build");
        assert_eq!(cmd.working_dir.as_deref(), Some("/app"));
        assert_eq!(cmd.timeout_secs, 300);
    }

    #[test]
    fn test_serialize_and_parse_command() {
        let executor = RelayExecutor::new(make_config());
        let cmd = executor.build_command("m1", "ls", None);
        let json = executor.serialize_command(&cmd).unwrap();
        assert!(json.contains("m1"));
        assert!(json.contains("ls"));
    }

    #[test]
    fn test_parse_response() {
        let executor = RelayExecutor::new(make_config());
        let json = r#"{"machine_id":"m1","stdout":"ok\n","stderr":"","exit_code":0,"duration_ms":42}"#;
        let resp = executor.parse_response(json).unwrap();
        assert_eq!(resp.machine_id, "m1");
        assert_eq!(resp.exit_code, 0);
        assert_eq!(resp.duration_ms, 42);
    }

    #[test]
    fn test_relay_response_into_remote_output() {
        let resp = RelayResponse {
            machine_id: "m1".into(),
            stdout: "output".into(),
            stderr: "warn".into(),
            exit_code: 0,
            duration_ms: 100,
        };
        let output: RemoteOutput = resp.into();
        assert_eq!(output.machine_id, "m1");
        assert!(output.success());
    }

    #[test]
    fn test_executor_type() {
        let executor = RelayExecutor::new(make_config());
        assert_eq!(executor.executor_type(), "relay");
    }

    #[test]
    fn test_relay_command_serialization() {
        let cmd = RelayCommand {
            target_machine: "m1".into(),
            command: "echo hello".into(),
            working_dir: None,
            timeout_secs: 30,
        };
        let json = serde_json::to_string(&cmd).unwrap();
        let back: RelayCommand = serde_json::from_str(&json).unwrap();
        assert_eq!(cmd.target_machine, back.target_machine);
        assert_eq!(cmd.timeout_secs, back.timeout_secs);
    }

    #[test]
    fn test_relay_config_serialization() {
        let config = make_config();
        let json = serde_json::to_string(&config).unwrap();
        let back: RelayConfig = serde_json::from_str(&json).unwrap();
        assert_eq!(config.relay_url, back.relay_url);
        assert_eq!(config.channel_id, back.channel_id);
    }
}