lha 1.0.2

Long-Horizon Agent command-line package that installs the lha binary.
Documentation 
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

use std::path::PathBuf;
use std::sync::Arc;
use std::sync::RwLock;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CodexAuth {
    api_key: String,
}

impl CodexAuth {
    pub fn from_api_key(api_key: impl Into<String>) -> Self {
        Self {
            api_key: api_key.into(),
        }
    }

    pub fn get_token(&self) -> anyhow::Result<String> {
        Ok(self.api_key.clone())
    }

    pub fn from_auth_storage(
        _lha_home: &std::path::Path,
        _auth_credentials_store_mode: AuthCredentialsStoreMode,
    ) -> std::io::Result<Option<Self>> {
        Ok(Some(Self::from_api_key("test")))
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum AuthCredentialsStoreMode {
    #[default]
    File,
    Keyring,
    Auto,
    Ephemeral,
}

#[derive(Debug)]
pub struct AuthManager {
    auth: RwLock<Option<CodexAuth>>,
}

impl AuthManager {
    pub fn new(
        _lha_home: PathBuf,
        _prefer_api_key: bool,
        _auth_credentials_store_mode: AuthCredentialsStoreMode,
    ) -> Self {
        Self {
            auth: RwLock::new(None),
        }
    }

    pub fn shared(lha_home: PathBuf, prefer_api_key: bool) -> Arc<Self> {
        Arc::new(Self::new(
            lha_home,
            prefer_api_key,
            AuthCredentialsStoreMode::File,
        ))
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn from_auth_for_testing(auth: CodexAuth) -> Arc<Self> {
        Arc::new(Self {
            auth: RwLock::new(Some(auth)),
        })
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn from_auth_for_testing_with_home(auth: CodexAuth, _lha_home: PathBuf) -> Arc<Self> {
        Self::from_auth_for_testing(auth)
    }

    pub fn auth_cached(&self) -> Option<CodexAuth> {
        self.auth.read().ok().and_then(|guard| guard.clone())
    }

    pub async fn auth(&self) -> Option<CodexAuth> {
        self.auth_cached()
    }

    pub fn get_auth_mode(&self) -> Option<String> {
        self.auth_cached().map(|_| "apikey".to_string())
    }
}

pub async fn load_auth(
    _lha_home: &std::path::Path,
    _prefer_api_key: bool,
) -> std::io::Result<Option<CodexAuth>> {
    Ok(None)
}

pub fn logout(_lha_home: &std::path::Path) -> std::io::Result<bool> {
    Ok(false)
}