codex-rs/cli/src/doctor/system.rs

use std::collections::BTreeMap;
use std::env;

use super::DoctorCheck;
use super::LOCALE_ENV_VARS;

const EDITOR_ENV_VARS: &[&str] = &["VISUAL", "EDITOR"];
const PAGER_ENV_VARS: &[&str] = &["PAGER", "GIT_PAGER", "GH_PAGER", "LESS"];

#[derive(Clone, Debug, Default, Eq, PartialEq)]
struct SystemCheckInputs {
    os: String,
    os_type: String,
    os_version: String,
    os_language: Option<String>,
    locale_env: BTreeMap<String, String>,
    editor_env: BTreeMap<String, String>,
    pager_env: BTreeMap<String, String>,
}

impl SystemCheckInputs {
    fn detect() -> Self {
        let info = os_info::get();
        let locale_env = LOCALE_ENV_VARS
            .iter()
            .filter_map(|name| {
                env::var(name)
                    .ok()
                    .map(|value| ((*name).to_string(), value))
            })
            .collect();
        let editor_env = EDITOR_ENV_VARS
            .iter()
            .map(|name| {
                let value = env::var_os(name)
                    .map(|value| value.to_string_lossy().into_owned())
                    .unwrap_or_else(|| "not set".to_string());
                ((*name).to_string(), value)
            })
            .collect();
        let pager_env = PAGER_ENV_VARS
            .iter()
            .filter_map(|name| {
                env::var_os(name)
                    .map(|value| ((*name).to_string(), value.to_string_lossy().into_owned()))
            })
            .collect();
        Self {
            os: info.to_string(),
            os_type: info.os_type().to_string(),
            os_version: info.version().to_string(),
            os_language: sys_locale::get_locale(),
            locale_env,
            editor_env,
            pager_env,
        }
    }
}

pub(super) fn system_check() -> DoctorCheck {
    system_check_from_inputs(SystemCheckInputs::detect())
}

fn system_check_from_inputs(inputs: SystemCheckInputs) -> DoctorCheck {
    let mut details = vec![
        format!("os: {}", inputs.os),
        format!("os type: {}", inputs.os_type),
        format!("os version: {}", inputs.os_version),
    ];
    if let Some(language) = inputs.os_language.as_deref() {
        details.push(format!("os language: {language}"));
    } else {
        details.push("os language: unavailable".to_string());
    }
    for name in LOCALE_ENV_VARS {
        if let Some(value) = inputs.locale_env.get(*name) {
            details.push(format!("{name}: {value}"));
        }
    }
    for name in EDITOR_ENV_VARS {
        if let Some(value) = inputs.editor_env.get(*name) {
            details.push(format!("{name}: {value}"));
        }
    }
    for name in PAGER_ENV_VARS {
        if let Some(value) = inputs.pager_env.get(*name) {
            details.push(format!("{name}: {value}"));
        }
    }

    let summary = inputs
        .os_language
        .as_deref()
        .map(|language| format!("OS language {language}"))
        .unwrap_or_else(|| "OS language unavailable".to_string());
    DoctorCheck::new(
        "system.environment",
        "system",
        super::CheckStatus::Ok,
        summary,
    )
    .details(details)
}

#[cfg(test)]
mod tests {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn system_check_reports_os_language_locale_editor_and_pager_env() {
        let mut locale_env = BTreeMap::new();
        locale_env.insert("LANG".to_string(), "en_US.UTF-8".to_string());
        let editor_env = BTreeMap::from([
            ("EDITOR".to_string(), "vim".to_string()),
            ("VISUAL".to_string(), "code --wait".to_string()),
        ]);
        let pager_env = BTreeMap::from([
            ("GH_PAGER".to_string(), "less".to_string()),
            ("GIT_PAGER".to_string(), "delta".to_string()),
            ("LESS".to_string(), "-FRX".to_string()),
            ("PAGER".to_string(), "less -R".to_string()),
        ]);
        let check = system_check_from_inputs(SystemCheckInputs {
            os: "macOS 15.0".to_string(),
            os_type: "macos".to_string(),
            os_version: "15.0".to_string(),
            os_language: Some("en-US".to_string()),
            locale_env,
            editor_env,
            pager_env,
        });

        assert_eq!(check.summary, "OS language en-US");
        assert_eq!(
            check.details,
            vec![
                "os: macOS 15.0",
                "os type: macos",
                "os version: 15.0",
                "os language: en-US",
                "LANG: en_US.UTF-8",
                "VISUAL: code --wait",
                "EDITOR: vim",
                "PAGER: less -R",
                "GIT_PAGER: delta",
                "GH_PAGER: less",
                "LESS: -FRX",
            ]
        );
    }

    #[test]
    fn system_check_handles_missing_os_language() {
        let check = system_check_from_inputs(SystemCheckInputs {
            os: "Linux".to_string(),
            os_type: "linux".to_string(),
            os_version: "unknown".to_string(),
            os_language: None,
            locale_env: BTreeMap::new(),
            editor_env: BTreeMap::from([
                ("EDITOR".to_string(), "not set".to_string()),
                ("VISUAL".to_string(), "not set".to_string()),
            ]),
            pager_env: BTreeMap::new(),
        });

        assert_eq!(check.summary, "OS language unavailable");
        assert_eq!(
            check.details,
            vec![
                "os: Linux",
                "os type: linux",
                "os version: unknown",
                "os language: unavailable",
                "VISUAL: not set",
                "EDITOR: not set",
            ]
        );
    }
}