agent-relay 0.4.1

//! Install the relay server as a persistent system service.
//!
//! - macOS: LaunchAgent plist
//! - Linux: systemd user service

use std::path::{Path, PathBuf};

const LABEL: &str = "com.naridon.agent-relay-server";
#[cfg(target_os = "linux")]
const SERVICE_NAME: &str = "agent-relay-server";

/// Install the server as a persistent background service.
pub fn install(binary: &Path, port: u16, bind: &str, data_dir: &Path) -> Result<String, String> {
    #[cfg(target_os = "macos")]
    {
        install_launchagent(binary, port, bind, data_dir)
    }

    #[cfg(target_os = "linux")]
    {
        install_systemd(binary, port, bind, data_dir)
    }

    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
    {
        let _ = (binary, port, bind, data_dir);
        Err("Server install not supported on this platform.".to_string())
    }
}

/// Uninstall the server service.
pub fn uninstall() -> Result<String, String> {
    #[cfg(target_os = "macos")]
    {
        uninstall_launchagent()
    }

    #[cfg(target_os = "linux")]
    {
        uninstall_systemd()
    }

    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
    {
        Err("Server uninstall not supported on this platform.".to_string())
    }
}

/// Check server service status.
pub fn status() -> Result<String, String> {
    #[cfg(target_os = "macos")]
    {
        status_launchagent()
    }

    #[cfg(target_os = "linux")]
    {
        status_systemd()
    }

    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
    {
        Err("Server status not supported on this platform.".to_string())
    }
}

// ── macOS LaunchAgent ──

#[cfg(target_os = "macos")]
fn plist_path() -> PathBuf {
    let home = std::env::var("HOME").unwrap_or_default();
    PathBuf::from(home)
        .join("Library/LaunchAgents")
        .join(format!("{}.plist", LABEL))
}

#[cfg(target_os = "macos")]
fn install_launchagent(
    binary: &Path,
    port: u16,
    bind: &str,
    data_dir: &Path,
) -> Result<String, String> {
    let plist_dir = plist_path().parent().unwrap().to_path_buf();
    let _ = std::fs::create_dir_all(&plist_dir);

    let log_dir = PathBuf::from(std::env::var("HOME").unwrap_or_default()).join(".agent-relay");
    let _ = std::fs::create_dir_all(&log_dir);

    let plist = format!(
        r#"<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>{label}</string>
    <key>ProgramArguments</key>
    <array>
        <string>{binary}</string>
        <string>server</string>
        <string>run</string>
        <string>--port</string>
        <string>{port}</string>
        <string>--bind</string>
        <string>{bind}</string>
        <string>--data-dir</string>
        <string>{data_dir}</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
    <key>StandardOutPath</key>
    <string>{log_dir}/server.log</string>
    <key>StandardErrorPath</key>
    <string>{log_dir}/server.err</string>
</dict>
</plist>"#,
        label = LABEL,
        binary = binary.display(),
        port = port,
        bind = bind,
        data_dir = data_dir.display(),
        log_dir = log_dir.display(),
    );

    let path = plist_path();
    std::fs::write(&path, plist).map_err(|e| format!("Failed to write plist: {}", e))?;

    // Unload if already loaded, then load
    let _ = std::process::Command::new("launchctl")
        .args(["unload", &path.to_string_lossy()])
        .output();

    let output = std::process::Command::new("launchctl")
        .args(["load", &path.to_string_lossy()])
        .output()
        .map_err(|e| format!("launchctl load failed: {}", e))?;

    if !output.status.success() {
        return Err(format!(
            "launchctl load failed: {}",
            String::from_utf8_lossy(&output.stderr)
        ));
    }

    Ok(format!(
        "Server installed at {}\nListening on {}:{}\nDatabase: {}/relay.db\nLogs: {}/server.log",
        path.display(),
        bind,
        port,
        data_dir.display(),
        log_dir.display()
    ))
}

#[cfg(target_os = "macos")]
fn uninstall_launchagent() -> Result<String, String> {
    let path = plist_path();
    if path.exists() {
        let _ = std::process::Command::new("launchctl")
            .args(["unload", &path.to_string_lossy()])
            .output();
        let _ = std::fs::remove_file(&path);
        Ok(format!("Server service uninstalled ({})", path.display()))
    } else {
        Ok("No server service installed.".to_string())
    }
}

#[cfg(target_os = "macos")]
fn status_launchagent() -> Result<String, String> {
    let output = std::process::Command::new("launchctl")
        .args(["list", LABEL])
        .output()
        .map_err(|e| format!("launchctl list failed: {}", e))?;

    if output.status.success() {
        let stdout = String::from_utf8_lossy(&output.stdout);
        Ok(format!("Server is running:\n{}", stdout))
    } else {
        Ok("Server is not running.".to_string())
    }
}

// ── Linux systemd ──

#[cfg(target_os = "linux")]
fn service_path() -> PathBuf {
    let home = std::env::var("HOME").unwrap_or_default();
    PathBuf::from(home)
        .join(".config/systemd/user")
        .join(format!("{}.service", SERVICE_NAME))
}

#[cfg(target_os = "linux")]
fn install_systemd(
    binary: &Path,
    port: u16,
    bind: &str,
    data_dir: &Path,
) -> Result<String, String> {
    let svc_dir = service_path().parent().unwrap().to_path_buf();
    let _ = std::fs::create_dir_all(&svc_dir);

    let unit = format!(
        r#"[Unit]
Description=agent-relay server — persistent relay for AI agent messaging
After=network.target

[Service]
Type=simple
ExecStart={binary} server run --port {port} --bind {bind} --data-dir {data_dir}
Restart=always
RestartSec=5

[Install]
WantedBy=default.target
"#,
        binary = binary.display(),
        port = port,
        bind = bind,
        data_dir = data_dir.display(),
    );

    let path = service_path();
    std::fs::write(&path, unit).map_err(|e| format!("Failed to write service: {}", e))?;

    let _ = std::process::Command::new("systemctl")
        .args(["--user", "daemon-reload"])
        .output();

    let output = std::process::Command::new("systemctl")
        .args(["--user", "enable", "--now", SERVICE_NAME])
        .output()
        .map_err(|e| format!("systemctl enable failed: {}", e))?;

    if !output.status.success() {
        return Err(format!(
            "systemctl enable failed: {}",
            String::from_utf8_lossy(&output.stderr)
        ));
    }

    Ok(format!(
        "Server installed at {}\nListening on {}:{}\nDatabase: {}/relay.db",
        path.display(),
        bind,
        port,
        data_dir.display()
    ))
}

#[cfg(target_os = "linux")]
fn uninstall_systemd() -> Result<String, String> {
    let _ = std::process::Command::new("systemctl")
        .args(["--user", "stop", SERVICE_NAME])
        .output();
    let _ = std::process::Command::new("systemctl")
        .args(["--user", "disable", SERVICE_NAME])
        .output();

    let path = service_path();
    if path.exists() {
        let _ = std::fs::remove_file(&path);
        let _ = std::process::Command::new("systemctl")
            .args(["--user", "daemon-reload"])
            .output();
        Ok(format!("Server service uninstalled ({})", path.display()))
    } else {
        Ok("No server service installed.".to_string())
    }
}

#[cfg(target_os = "linux")]
fn status_systemd() -> Result<String, String> {
    let output = std::process::Command::new("systemctl")
        .args(["--user", "status", SERVICE_NAME])
        .output()
        .map_err(|e| format!("systemctl status failed: {}", e))?;

    Ok(String::from_utf8_lossy(&output.stdout).to_string())
}