regy 0.1.0

Private-by-default desktop agent for the Regy web interface
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

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

use crate::domain::errors::{AgentError, AgentResult, ErrorCode};

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct PathEnvironment {
    pub home: Option<PathBuf>,
    pub xdg_config_home: Option<PathBuf>,
    pub xdg_data_home: Option<PathBuf>,
    pub xdg_cache_home: Option<PathBuf>,
}

impl PathEnvironment {
    pub(crate) fn from_env() -> Self {
        Self {
            home: std::env::var_os("HOME").map(PathBuf::from),
            xdg_config_home: std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from),
            xdg_data_home: std::env::var_os("XDG_DATA_HOME").map(PathBuf::from),
            xdg_cache_home: std::env::var_os("XDG_CACHE_HOME").map(PathBuf::from),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct AppPaths {
    pub config_file: PathBuf,
    pub data_dir: PathBuf,
    pub server_key_file: PathBuf,
    pub clients_file: PathBuf,
    pub cache_dir: PathBuf,
}

impl AppPaths {
    pub(crate) fn resolve(
        config_override: Option<PathBuf>,
        environment: &PathEnvironment,
    ) -> AgentResult<Self> {
        let config_file = match usable_path(config_override.as_deref()) {
            Some(path) => path.to_path_buf(),
            None => resolve_base(
                environment.xdg_config_home.as_deref(),
                environment.home.as_deref(),
                ".config",
                "XDG_CONFIG_HOME",
            )?
            .join("regy/pc-agent.toml"),
        };
        let data_dir = resolve_base(
            environment.xdg_data_home.as_deref(),
            environment.home.as_deref(),
            ".local/share",
            "XDG_DATA_HOME",
        )?
        .join("regy/pc-agent");
        let cache_dir = resolve_base(
            environment.xdg_cache_home.as_deref(),
            environment.home.as_deref(),
            ".cache",
            "XDG_CACHE_HOME",
        )?
        .join("regy");
        let server_key_file = data_dir.join("server-key");
        let clients_file = data_dir.join("clients.json");

        Ok(Self {
            config_file,
            data_dir,
            server_key_file,
            clients_file,
            cache_dir,
        })
    }

    pub(crate) fn server_lock_file(&self) -> PathBuf {
        self.data_dir.join("server.lock")
    }

    pub(crate) fn daemon_log_file(&self) -> PathBuf {
        self.cache_dir.join("pc-agent.log")
    }

    pub(crate) fn iroh_endpoint_key_file(&self) -> PathBuf {
        self.data_dir.join("iroh-endpoint.key")
    }
}

fn resolve_base(
    xdg: Option<&Path>,
    home: Option<&Path>,
    fallback: &str,
    variable: &str,
) -> AgentResult<PathBuf> {
    if let Some(path) = usable_path(xdg).filter(|path| path.is_absolute()) {
        return Ok(path.to_path_buf());
    }
    let home = usable_path(home).ok_or_else(|| {
        AgentError::new(
            ErrorCode::InvalidMessage,
            format!("HOME must be set and non-empty when {variable} is not usable"),
        )
    })?;
    Ok(home.join(fallback))
}

fn usable_path(path: Option<&Path>) -> Option<&Path> {
    path.filter(|path| !path.as_os_str().is_empty() && !path.to_string_lossy().trim().is_empty())
}