cli_shared/config/
user_config.rs

1// SPDX-License-Identifier: Apache-2.0
2use std::{
3    collections::BTreeMap,
4    env, fs,
5    io::Read,
6    path::{Path, PathBuf},
7};
8
9use objects::fs_atomic::write_file_atomic_secret;
10use repo::{FsMonitorMode, FsMonitorSettings, OutputFormat, WorktreeStatusOptions};
11use serde::{Deserialize, Serialize};
12use wire::AuthToken;
13
14use crate::client_config::ClientConfig;
15
16#[derive(Debug, Clone, Serialize, Deserialize, Default)]
17pub struct UserConfig {
18    #[serde(default)]
19    pub principal: Option<UserPrincipalConfig>,
20    #[serde(default)]
21    pub agent: UserAgentConfig,
22    #[serde(default)]
23    pub capture: UserCaptureConfig,
24    #[serde(default)]
25    pub output: UserOutputConfig,
26    #[serde(default)]
27    pub display: UserDisplayConfig,
28    #[serde(default)]
29    pub worktree: UserWorktreeConfig,
30    #[serde(default)]
31    pub logging: UserLoggingConfig,
32    #[serde(default)]
33    pub remote: UserRemoteConfig,
34    #[serde(default)]
35    pub harness: UserHarnessConfig,
36    #[serde(default)]
37    pub land: UserLandConfig,
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
41pub struct UserPrincipalConfig {
42    pub name: String,
43    pub email: String,
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize, Default)]
47pub struct UserAgentConfig {
48    #[serde(default)]
49    pub provider: Option<String>,
50    #[serde(default)]
51    pub model: Option<String>,
52    #[serde(default)]
53    pub default_policy: Option<String>,
54    #[serde(default = "default_confidence")]
55    pub confidence: f32,
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize, Default)]
59pub struct UserCaptureConfig {
60    #[serde(default)]
61    pub auto: UserAutoCaptureMode,
62}
63
64#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
65#[serde(rename_all = "lowercase")]
66pub enum UserAutoCaptureMode {
67    #[default]
68    Off,
69    Command,
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize, Default)]
73pub struct UserOutputConfig {
74    #[serde(default)]
75    pub format: OutputFormat,
76}
77
78#[derive(Debug, Clone, Serialize, Deserialize)]
79pub struct UserDisplayConfig {
80    #[serde(default = "default_hash_length")]
81    pub hash_length: usize,
82    #[serde(default = "default_change_id_format")]
83    pub change_id_format: String,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize, Default)]
87pub struct UserWorktreeConfig {
88    #[serde(default)]
89    pub fsmonitor: UserFsMonitorConfig,
90    #[serde(default)]
91    pub thread_workspace: UserThreadWorkspaceConfig,
92}
93
94#[derive(Debug, Clone, Serialize, Deserialize, Default)]
95pub struct UserFsMonitorConfig {
96    #[serde(default)]
97    pub mode: Option<FsMonitorMode>,
98}
99
100/// User-config default for thread workspace mode. Same vocabulary
101/// as [`crate::config::repo::ThreadMode`] and the `--workspace` flag,
102/// so a user setting `top_level_default = "materialized"` reads
103/// uniformly across the CLI surface and the thread record on disk.
104#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
105#[serde(rename_all = "kebab-case")]
106pub enum UserThreadWorkspaceMode {
107    #[default]
108    Auto,
109    Materialized,
110    Virtualized,
111    Solid,
112}
113
114#[derive(Debug, Clone, Serialize, Deserialize, Default)]
115pub struct UserThreadWorkspaceConfig {
116    #[serde(default)]
117    pub top_level_default: UserThreadWorkspaceMode,
118    #[serde(default)]
119    pub delegated_default: Option<UserThreadWorkspaceMode>,
120}
121
122#[derive(Debug, Clone, Serialize, Deserialize, Default)]
123pub struct UserLoggingConfig {
124    #[serde(default)]
125    pub format: Option<String>,
126    #[serde(default)]
127    pub include_location: bool,
128    #[serde(default)]
129    pub include_thread_ids: bool,
130    #[serde(default)]
131    pub log_spans: bool,
132    #[serde(default)]
133    pub otel_service_name: Option<String>,
134    #[serde(default)]
135    pub otel_endpoint: Option<String>,
136    #[serde(default)]
137    pub otel_traces_endpoint: Option<String>,
138    #[serde(default)]
139    pub otel_metrics_endpoint: Option<String>,
140}
141
142#[derive(Debug, Clone, Serialize, Deserialize, Default)]
143pub struct UserRemoteConfig {
144    #[serde(default)]
145    pub token: Option<String>,
146    #[serde(default)]
147    pub tls_enabled: bool,
148    #[serde(default)]
149    pub tls_domain_name: Option<String>,
150    #[serde(default)]
151    pub tls_ca_certificate_path: Option<PathBuf>,
152    #[serde(default)]
153    pub auth_proof_key_pem_path: Option<PathBuf>,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
157pub struct UserLandConfig {
158    #[serde(default = "default_land_squash")]
159    pub squash: bool,
160}
161
162#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
163#[serde(rename_all = "lowercase")]
164pub enum HarnessMode {
165    #[default]
166    Auto,
167    Off,
168    Required,
169}
170
171#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
172#[serde(rename_all = "lowercase")]
173pub enum HarnessTransport {
174    #[default]
175    Spool,
176    Direct,
177    End,
178}
179
180#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
181#[serde(rename_all = "lowercase")]
182pub enum HarnessTranscriptMode {
183    #[default]
184    Off,
185    Summary,
186    Full,
187}
188
189#[derive(Debug, Clone, Serialize, Deserialize, Default)]
190pub struct UserHarnessOverride {
191    #[serde(default)]
192    pub provider: Option<String>,
193    #[serde(default)]
194    pub model: Option<String>,
195    #[serde(default)]
196    pub thinking_level: Option<String>,
197    #[serde(default)]
198    pub policy: Option<String>,
199}
200
201#[derive(Debug, Clone, Serialize, Deserialize)]
202pub struct UserHarnessConfig {
203    #[serde(default)]
204    pub mode: HarnessMode,
205    #[serde(default)]
206    pub transport: HarnessTransport,
207    #[serde(default)]
208    pub transcript: HarnessTranscriptMode,
209    #[serde(default = "default_auto_infer")]
210    pub auto_infer: bool,
211    #[serde(default)]
212    pub threading: UserHarnessThreadingConfig,
213    #[serde(default)]
214    pub harnesses: BTreeMap<String, UserHarnessOverride>,
215}
216
217#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
218#[serde(rename_all = "kebab-case")]
219pub enum UserHarnessRootThreadPolicy {
220    CreateNew,
221    #[default]
222    AttachCurrent,
223}
224
225#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
226#[serde(rename_all = "kebab-case")]
227pub enum UserHarnessSubagentThreadPolicy {
228    AttachCurrent,
229    #[default]
230    CreateChild,
231}
232
233#[derive(Debug, Clone, Serialize, Deserialize, Default)]
234pub struct UserHarnessThreadingConfig {
235    #[serde(default)]
236    pub root_actor: UserHarnessRootThreadPolicy,
237    #[serde(default)]
238    pub subagent: UserHarnessSubagentThreadPolicy,
239    #[serde(default)]
240    pub workspace_default: Option<UserThreadWorkspaceMode>,
241}
242
243fn default_confidence() -> f32 {
244    0.8
245}
246
247fn default_hash_length() -> usize {
248    8
249}
250
251fn default_change_id_format() -> String {
252    "short".to_string()
253}
254
255fn default_auto_infer() -> bool {
256    true
257}
258
259fn default_land_squash() -> bool {
260    true
261}
262
263impl Default for UserDisplayConfig {
264    fn default() -> Self {
265        Self {
266            hash_length: default_hash_length(),
267            change_id_format: default_change_id_format(),
268        }
269    }
270}
271
272impl Default for UserHarnessConfig {
273    fn default() -> Self {
274        Self {
275            mode: HarnessMode::Auto,
276            transport: HarnessTransport::Spool,
277            transcript: HarnessTranscriptMode::Off,
278            auto_infer: default_auto_infer(),
279            threading: UserHarnessThreadingConfig::default(),
280            harnesses: BTreeMap::new(),
281        }
282    }
283}
284
285impl Default for UserLandConfig {
286    fn default() -> Self {
287        Self {
288            squash: default_land_squash(),
289        }
290    }
291}
292
293impl UserConfig {
294    pub fn default_path() -> Option<PathBuf> {
295        if let Ok(path) = std::env::var("HEDDLE_CONFIG")
296            && !path.is_empty()
297        {
298            return Some(PathBuf::from(path));
299        }
300        if let Ok(xdg) = std::env::var("XDG_CONFIG_HOME")
301            && !xdg.is_empty()
302        {
303            return Some(PathBuf::from(xdg).join("heddle").join("config.toml"));
304        }
305        if let Ok(home) = std::env::var("HOME")
306            && !home.is_empty()
307        {
308            return Some(PathBuf::from(home).join(".config/heddle/config.toml"));
309        }
310        None
311    }
312
313    pub fn load(path: &Path) -> anyhow::Result<Self> {
314        let mut file = fs::File::open(path)?;
315        let mut contents = String::new();
316        file.read_to_string(&mut contents)?;
317        // Route TOML parse failures through `HeddleError::ConfigParse` so
318        // the CLI error envelope (see `print_error_with_hint`) can
319        // classify them and render the *actual* source file in the
320        // recovery advice — not a hard-coded `.heddle/config.toml`
321        // (Codex R3 cid 3313132711 on #271). The path is canonicalized
322        // so the rendered hint is copy/paste-safe even when the caller
323        // passed a relative or env-derived path.
324        toml::from_str::<Self>(&contents).map_err(|err| {
325            let resolved = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
326            objects::error::HeddleError::ConfigParse {
327                path: resolved,
328                source: err,
329            }
330            .into()
331        })
332    }
333
334    pub fn load_default() -> anyhow::Result<Self> {
335        match Self::default_path() {
336            Some(path) => match Self::load(&path) {
337                Ok(config) => Ok(config),
338                Err(err) if path_missing(&err) => Ok(Self::default()),
339                Err(err) => Err(err),
340            },
341            None => Ok(Self::default()),
342        }
343    }
344
345    pub fn save_default(&self) -> anyhow::Result<PathBuf> {
346        let path = Self::default_path()
347            .ok_or_else(|| anyhow::anyhow!("unable to determine user config path"))?;
348        self.save(&path)?;
349        Ok(path)
350    }
351
352    pub fn save(&self, path: &Path) -> anyhow::Result<()> {
353        if let Some(parent) = path.parent() {
354            fs::create_dir_all(parent)?;
355        }
356        let contents = toml::to_string_pretty(self)?;
357        write_file_atomic_secret(path, contents.as_bytes())?;
358        Ok(())
359    }
360
361    pub fn set_principal(&mut self, name: impl Into<String>, email: impl Into<String>) {
362        self.principal = Some(UserPrincipalConfig {
363            name: name.into(),
364            email: email.into(),
365        });
366    }
367
368    pub fn remote_token(&self) -> anyhow::Result<Option<AuthToken>> {
369        match env::var("HEDDLE_REMOTE_TOKEN") {
370            Ok(token) if !token.is_empty() => Ok(Some(AuthToken::new(token, "env"))),
371            Ok(_) | Err(env::VarError::NotPresent) => Ok(self
372                .remote
373                .token
374                .clone()
375                .map(|token| AuthToken::new(token, "user-config"))),
376            Err(err @ env::VarError::NotUnicode(_)) => Err(security_config_error(
377                "HEDDLE_REMOTE_TOKEN",
378                format!("read environment value: {err}"),
379            )),
380        }
381    }
382
383    pub fn command_auto_capture_enabled(&self) -> anyhow::Result<bool> {
384        let mut mode = self.capture.auto;
385        match env::var("HEDDLE_AUTO_CAPTURE") {
386            Ok(value) if !value.trim().is_empty() => {
387                mode = parse_auto_capture_env("HEDDLE_AUTO_CAPTURE", &value)?;
388            }
389            Ok(_) | Err(env::VarError::NotPresent) => {}
390            Err(err @ env::VarError::NotUnicode(_)) => {
391                return Err(config_value_error(
392                    "HEDDLE_AUTO_CAPTURE",
393                    format!("read environment value: {err}"),
394                ));
395            }
396        }
397        Ok(matches!(mode, UserAutoCaptureMode::Command))
398    }
399
400    pub fn heddle_client_config(
401        &self,
402        token_override: Option<AuthToken>,
403    ) -> anyhow::Result<ClientConfig> {
404        let token = match token_override {
405            Some(token) => Some(token),
406            None => self.remote_token()?,
407        };
408        let mut config = token
409            .map(|token| ClientConfig::default().with_token(token))
410            .unwrap_or_default();
411
412        if self.remote.tls_enabled {
413            config = config.with_tls(false);
414        }
415        if let Some(domain) = &self.remote.tls_domain_name {
416            config = config.with_tls_domain_name(domain.clone());
417        }
418        if let Some(path) = &self.remote.tls_ca_certificate_path {
419            let pem = read_security_config_file("remote.tls_ca_certificate_path", path)?;
420            config = config.with_tls_ca_certificate_pem(pem);
421        }
422        if let Some(path) = &self.remote.auth_proof_key_pem_path {
423            let pem = read_security_config_file("remote.auth_proof_key_pem_path", path)?;
424            config = config.with_auth_proof_key_pem(pem);
425        }
426
427        if env_bool("HEDDLE_REMOTE_TLS")? {
428            config = config.with_tls(false);
429        }
430        match env::var("HEDDLE_REMOTE_TLS_DOMAIN") {
431            Ok(domain) => config = config.with_tls_domain_name(domain),
432            Err(env::VarError::NotPresent) => {}
433            Err(err @ env::VarError::NotUnicode(_)) => {
434                return Err(security_config_error(
435                    "HEDDLE_REMOTE_TLS_DOMAIN",
436                    format!("read environment value: {err}"),
437                ));
438            }
439        }
440        match env::var("HEDDLE_REMOTE_TLS_CA_CERT") {
441            Ok(path) => {
442                let pem =
443                    read_security_config_file("HEDDLE_REMOTE_TLS_CA_CERT", &PathBuf::from(path))?;
444                config = config.with_tls_ca_certificate_pem(pem);
445            }
446            Err(env::VarError::NotPresent) => {}
447            Err(err @ env::VarError::NotUnicode(_)) => {
448                return Err(security_config_error(
449                    "HEDDLE_REMOTE_TLS_CA_CERT",
450                    format!("read environment value: {err}"),
451                ));
452            }
453        }
454        Ok(config)
455    }
456
457    pub fn worktree_status_options(
458        &self,
459        repo_config: Option<&repo::RepoConfig>,
460    ) -> WorktreeStatusOptions {
461        let mut mode = self
462            .worktree
463            .fsmonitor
464            .mode
465            .or_else(|| repo_config.map(|config| config.worktree.fsmonitor.mode))
466            .unwrap_or(FsMonitorMode::Off);
467        if let Ok(value) = std::env::var("HEDDLE_FSMONITOR")
468            && let Some(parsed) = FsMonitorMode::parse(&value)
469        {
470            mode = parsed;
471        }
472
473        WorktreeStatusOptions {
474            fsmonitor: FsMonitorSettings { mode },
475        }
476    }
477}
478
479fn parse_auto_capture_env(setting: &str, value: &str) -> anyhow::Result<UserAutoCaptureMode> {
480    match value.trim().to_ascii_lowercase().as_str() {
481        "1" | "true" | "yes" | "on" | "command" | "commands" => Ok(UserAutoCaptureMode::Command),
482        "0" | "false" | "no" | "off" => Ok(UserAutoCaptureMode::Off),
483        _ => Err(config_value_error(
484            setting,
485            format!(
486                "parse auto-capture value {value:?}; expected one of off, command, true, or false"
487            ),
488        )),
489    }
490}
491
492fn read_security_config_file(setting: &str, path: &Path) -> anyhow::Result<String> {
493    fs::read_to_string(path).map_err(|err| {
494        security_config_error(
495            setting,
496            format!("read configured file {}: {err}", path.display()),
497        )
498    })
499}
500
501fn env_bool(name: &str) -> anyhow::Result<bool> {
502    let value = match env::var(name) {
503        Ok(value) => value,
504        Err(env::VarError::NotPresent) => return Ok(false),
505        Err(err @ env::VarError::NotUnicode(_)) => {
506            return Err(security_config_error(
507                name,
508                format!("read environment value: {err}"),
509            ));
510        }
511    };
512    match value.trim().to_ascii_lowercase().as_str() {
513        "1" | "true" | "yes" | "on" => Ok(true),
514        "0" | "false" | "no" | "off" => Ok(false),
515        _ => Err(security_config_error(
516            name,
517            format!(
518                "parse boolean value {value:?}; expected one of 1/0, true/false, yes/no, or on/off"
519            ),
520        )),
521    }
522}
523
524fn config_value_error(setting: &str, reason: String) -> anyhow::Error {
525    anyhow::anyhow!("fatal configuration error for `{setting}`: {reason}")
526}
527
528fn security_config_error(setting: &str, reason: String) -> anyhow::Error {
529    anyhow::anyhow!(
530        "fatal TLS/auth configuration error for `{setting}`: {reason}; refusing to proceed with an ambiguous security posture"
531    )
532}
533
534fn path_missing(err: &anyhow::Error) -> bool {
535    err.downcast_ref::<std::io::Error>()
536        .is_some_and(|io| io.kind() == std::io::ErrorKind::NotFound)
537}
538
539#[cfg(test)]
540mod tests {
541    use std::{
542        ffi::OsString,
543        fs,
544        path::PathBuf,
545        sync::MutexGuard,
546        time::{SystemTime, UNIX_EPOCH},
547    };
548
549    use repo::{FsMonitorMode, RepoConfig};
550
551    use super::{
552        HarnessMode, HarnessTranscriptMode, HarnessTransport, UserAutoCaptureMode,
553        UserCaptureConfig, UserConfig, UserRemoteConfig,
554    };
555
556    static TEST_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
557    const REMOTE_ENV_KEYS: &[&str] = &[
558        "HEDDLE_REMOTE_TOKEN",
559        "HEDDLE_REMOTE_TLS",
560        "HEDDLE_REMOTE_TLS_DOMAIN",
561        "HEDDLE_REMOTE_TLS_CA_CERT",
562        "HEDDLE_AUTO_CAPTURE",
563    ];
564
565    struct RemoteEnvGuard {
566        _guard: MutexGuard<'static, ()>,
567        saved: Vec<(&'static str, Option<OsString>)>,
568    }
569
570    impl RemoteEnvGuard {
571        fn clean() -> Self {
572            let guard = TEST_ENV_LOCK
573                .lock()
574                .unwrap_or_else(|poisoned| poisoned.into_inner());
575            let saved = REMOTE_ENV_KEYS
576                .iter()
577                .map(|key| (*key, std::env::var_os(key)))
578                .collect();
579            for key in REMOTE_ENV_KEYS {
580                unsafe { std::env::remove_var(key) };
581            }
582            Self {
583                _guard: guard,
584                saved,
585            }
586        }
587
588        fn set(&self, key: &str, value: impl AsRef<std::ffi::OsStr>) {
589            unsafe { std::env::set_var(key, value) };
590        }
591    }
592
593    impl Drop for RemoteEnvGuard {
594        fn drop(&mut self) {
595            for (key, value) in &self.saved {
596                unsafe {
597                    if let Some(value) = value {
598                        std::env::set_var(key, value);
599                    } else {
600                        std::env::remove_var(key);
601                    }
602                }
603            }
604        }
605    }
606
607    fn unique_temp_path(prefix: &str) -> PathBuf {
608        let unique = SystemTime::now()
609            .duration_since(UNIX_EPOCH)
610            .expect("system time before unix epoch")
611            .as_nanos();
612        std::env::temp_dir().join(format!("{prefix}-{}-{unique}", std::process::id()))
613    }
614
615    #[test]
616    fn user_worktree_status_options_fall_back_to_repo_config() {
617        let mut repo = RepoConfig::default();
618        repo.worktree.fsmonitor.mode = FsMonitorMode::Watchman;
619
620        let config = UserConfig::default();
621        let options = config.worktree_status_options(Some(&repo));
622
623        assert_eq!(options.fsmonitor.mode, FsMonitorMode::Watchman);
624    }
625
626    #[test]
627    fn harness_config_defaults_are_magical_but_safe() {
628        let config = UserConfig::default();
629        assert_eq!(config.harness.mode, HarnessMode::Auto);
630        assert_eq!(config.harness.transport, HarnessTransport::Spool);
631        assert_eq!(config.harness.transcript, HarnessTranscriptMode::Off);
632        assert!(config.harness.auto_infer);
633        assert!(config.harness.harnesses.is_empty());
634    }
635
636    #[test]
637    fn command_auto_capture_defaults_off() {
638        let _env = RemoteEnvGuard::clean();
639
640        let config = UserConfig::default();
641
642        assert!(!config.command_auto_capture_enabled().unwrap());
643    }
644
645    #[test]
646    fn command_auto_capture_reads_user_config() {
647        let _env = RemoteEnvGuard::clean();
648        let config = UserConfig {
649            capture: UserCaptureConfig {
650                auto: UserAutoCaptureMode::Command,
651            },
652            ..UserConfig::default()
653        };
654
655        assert!(config.command_auto_capture_enabled().unwrap());
656    }
657
658    #[test]
659    fn command_auto_capture_env_overrides_user_config() {
660        let env = RemoteEnvGuard::clean();
661        env.set("HEDDLE_AUTO_CAPTURE", "off");
662        let config = UserConfig {
663            capture: UserCaptureConfig {
664                auto: UserAutoCaptureMode::Command,
665            },
666            ..UserConfig::default()
667        };
668
669        assert!(!config.command_auto_capture_enabled().unwrap());
670
671        env.set("HEDDLE_AUTO_CAPTURE", "command");
672        assert!(
673            UserConfig::default()
674                .command_auto_capture_enabled()
675                .unwrap()
676        );
677    }
678
679    #[test]
680    fn user_config_toml_parses_capture_auto_command() {
681        let parsed: UserConfig = toml::from_str(
682            r#"
683                [capture]
684                auto = "command"
685            "#,
686        )
687        .expect("capture auto config should parse");
688
689        assert_eq!(parsed.capture.auto, UserAutoCaptureMode::Command);
690    }
691
692    #[test]
693    fn heddle_client_config_absent_security_settings_uses_defaults() {
694        let _env = RemoteEnvGuard::clean();
695        let config = UserConfig::default()
696            .heddle_client_config(None)
697            .expect("absent optional settings should not error");
698
699        assert!(!config.tls_enabled);
700        assert!(!config.tls_skip_verify);
701        assert!(config.tls_ca_certificate_pem.is_none());
702        assert!(config.auth_proof_key_pem.is_none());
703        assert!(config.token.is_none());
704    }
705
706    #[test]
707    fn heddle_client_config_valid_security_files_are_applied() {
708        let _env = RemoteEnvGuard::clean();
709        let dir = unique_temp_path("heddle-user-config-valid-security");
710        fs::create_dir_all(&dir).expect("create temp dir");
711        let ca_path = dir.join("ca.pem");
712        let key_path = dir.join("proof-key.pem");
713        fs::write(&ca_path, "test ca pem").expect("write ca pem");
714        fs::write(&key_path, "test key pem").expect("write key pem");
715        let user = UserConfig {
716            remote: UserRemoteConfig {
717                tls_ca_certificate_path: Some(ca_path),
718                auth_proof_key_pem_path: Some(key_path),
719                ..UserRemoteConfig::default()
720            },
721            ..UserConfig::default()
722        };
723
724        let config = user
725            .heddle_client_config(None)
726            .expect("valid TLS/auth files should load");
727
728        assert!(config.tls_enabled);
729        assert_eq!(
730            config.tls_ca_certificate_pem.as_deref(),
731            Some("test ca pem")
732        );
733        assert_eq!(config.auth_proof_key_pem.as_deref(), Some("test key pem"));
734
735        fs::remove_dir_all(dir).expect("remove temp dir");
736    }
737
738    #[test]
739    fn heddle_client_config_missing_tls_ca_path_fails_closed() {
740        let _env = RemoteEnvGuard::clean();
741        let missing = unique_temp_path("heddle-user-config-missing-ca").join("ca.pem");
742        let user = UserConfig {
743            remote: UserRemoteConfig {
744                tls_ca_certificate_path: Some(missing),
745                ..UserRemoteConfig::default()
746            },
747            ..UserConfig::default()
748        };
749
750        let err = user
751            .heddle_client_config(None)
752            .expect_err("missing configured CA path must fail closed");
753        let message = err.to_string();
754
755        assert!(message.contains("fatal TLS/auth configuration error"));
756        assert!(message.contains("remote.tls_ca_certificate_path"));
757    }
758
759    #[test]
760    fn heddle_client_config_missing_auth_proof_key_path_fails_closed() {
761        let _env = RemoteEnvGuard::clean();
762        let missing = unique_temp_path("heddle-user-config-missing-key").join("proof-key.pem");
763        let user = UserConfig {
764            remote: UserRemoteConfig {
765                auth_proof_key_pem_path: Some(missing),
766                ..UserRemoteConfig::default()
767            },
768            ..UserConfig::default()
769        };
770
771        let err = user
772            .heddle_client_config(None)
773            .expect_err("missing configured proof key path must fail closed");
774        let message = err.to_string();
775
776        assert!(message.contains("fatal TLS/auth configuration error"));
777        assert!(message.contains("remote.auth_proof_key_pem_path"));
778    }
779
780    #[test]
781    fn heddle_client_config_missing_env_tls_ca_path_fails_closed() {
782        let env = RemoteEnvGuard::clean();
783        let missing = unique_temp_path("heddle-user-config-missing-env-ca").join("ca.pem");
784        env.set("HEDDLE_REMOTE_TLS_CA_CERT", missing);
785
786        let err = UserConfig::default()
787            .heddle_client_config(None)
788            .expect_err("missing env CA path must fail closed");
789        let message = err.to_string();
790
791        assert!(message.contains("fatal TLS/auth configuration error"));
792        assert!(message.contains("HEDDLE_REMOTE_TLS_CA_CERT"));
793    }
794
795    #[test]
796    fn heddle_client_config_invalid_env_tls_value_fails_closed() {
797        let env = RemoteEnvGuard::clean();
798        env.set("HEDDLE_REMOTE_TLS", "enabled");
799
800        let err = UserConfig::default()
801            .heddle_client_config(None)
802            .expect_err("invalid TLS env value must fail closed");
803        let message = err.to_string();
804
805        assert!(message.contains("fatal TLS/auth configuration error"));
806        assert!(message.contains("HEDDLE_REMOTE_TLS"));
807    }
808}
cli_shared/config/user_config.rs

cli_shared/config/
user_config.rs
