Skip to main content

qualia_client_core/
state.rs

1use crate::qapp_registry;
2use qualia_core_db::rpc::TaxRecipientSuite;
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::path::PathBuf;
6use std::sync::atomic::{AtomicBool, AtomicU32};
7use std::sync::{Arc, Mutex, OnceLock};
8
9pub static APP_STATE: OnceLock<Arc<AppState>> = OnceLock::new();
10
11/// Initializes app state.
12pub fn init_app_state() -> Arc<AppState> {
13    let config = load_config_from_disk();
14    init_data_directories(&config.storage_path);
15    let meta = app_meta_dir();
16    let _ = std::fs::create_dir_all(&meta);
17    let meta_str = meta.to_string_lossy().into_owned();
18    let tax_suite = load_suite_from_disk(&config.storage_path);
19    let vault = qualia_core_db::key_vault::KeyVault::load_or_generate(&meta_str)
20        .unwrap_or_else(|e| panic!("KeyVault init failed ({meta_str}): {e}"));
21    let state = build_app_state(config, vault, tax_suite);
22    APP_STATE.set(state.clone()).ok();
23    // Person ≠ machine: ensure person principal + local apparatus exist early.
24    // Failures are non-fatal at boot (e.g. read-only meta dir); setup/finish retries.
25    let _ = crate::identity_plane::ensure_local_apparatus(None);
26    state
27}
28
29/// Attach an explicitly opened native vault without creating identity, keys,
30/// directories, fleet records or services. Existing application state is never
31/// replaced. The native operator selects and opens the vault before this call.
32#[cfg(not(target_arch = "wasm32"))]
33pub fn init_inference_host_state(
34    vault: qualia_core_db::key_vault::KeyVault,
35) -> Result<Arc<AppState>, String> {
36    if vault.is_locked() {
37        return Err("An explicitly opened unlocked vault is required".into());
38    }
39    if APP_STATE.get().is_some() {
40        return Err("Application state is already initialized; use its existing host".into());
41    }
42    let state = build_app_state(
43        AgentConfig::default(),
44        vault,
45        TaxRecipientSuite::default_cooperative(),
46    );
47    APP_STATE
48        .set(Arc::clone(&state))
49        .map_err(|_| "Application state was initialized concurrently")?;
50    Ok(state)
51}
52fn build_app_state(
53    config: AgentConfig,
54    vault: qualia_core_db::key_vault::KeyVault,
55    tax_suite: TaxRecipientSuite,
56) -> Arc<AppState> {
57    Arc::new(AppState {
58        config: Mutex::new(config.clone()),
59        tax_suite: Mutex::new(tax_suite),
60        daemon_running: Arc::new(Mutex::new(false)),
61        nym_relay_active: Arc::new(AtomicBool::new(false)),
62        stark_prover_active: Arc::new(AtomicBool::new(false)),
63        simulated_solar_watts: Arc::new(AtomicU32::new(0)),
64        download_handles: Arc::new(Mutex::new(HashMap::new())),
65        active_downloads: Arc::new(Mutex::new(HashMap::new())),
66        active_model: Arc::new(Mutex::new(None)),
67        // rqbit_session: Arc::new(tokio::sync::Mutex::new(None)),
68        directory_actors: Arc::new(Mutex::new(Vec::new())),
69        delegation_rules: Arc::new(Mutex::new(Vec::new())),
70        front_doors: Arc::new(Mutex::new(Vec::new())),
71        installed_qapps: Arc::new(Mutex::new(Vec::new())),
72        key_vault: Arc::new(Mutex::new(vault)),
73        download_events: tokio::sync::broadcast::channel(100).0,
74    })
75}
76
77#[derive(Clone, Serialize)]
78pub struct RelayTelemetry {
79    pub packets_routed: u32,
80    pub packets_dropped: u32,
81    pub buffer_memory_mb: f64,
82    pub is_congested: bool,
83}
84
85#[derive(Clone, Serialize)]
86pub struct StarkTelemetry {
87    pub status: String,
88    pub cpu_utilization: f64,
89    pub ram_usage_mb: f64,
90    pub fragments_paged: u32,
91}
92
93// ── Config ────────────────────────────────────────────────────────────────────
94
95#[derive(Serialize, Deserialize, Clone)]
96pub struct AgentConfig {
97    pub storage_path: String,
98    pub storage_quota_gb: u64,
99    pub base_connectivity_cost_ilp: u64,
100    pub daemon_host: String,
101    pub daemon_port: u16,
102    pub inference_backend: String,
103    /// User-configurable port for the local web server (settings portal +
104    /// Studio WASM + companion gateway). Default: 8080. If 0, auto-finds
105    /// an open port starting from 8080.
106    pub settings_port: u16,
107    /// User-configurable external model directories scanned recursively for `.p64` / `.gguf` packages.
108    #[serde(default = "default_model_search_paths")]
109    pub model_search_paths: Vec<String>,
110}
111
112impl Default for AgentConfig {
113    fn default() -> Self {
114        Self {
115            storage_path: dirs_default_path(),
116            storage_quota_gb: 10,
117            base_connectivity_cost_ilp: 5000,
118            daemon_host: "127.0.0.1".to_string(),
119            daemon_port: 4242,
120            inference_backend: "local".to_string(),
121            settings_port: 8080,
122            model_search_paths: default_model_search_paths(),
123        }
124    }
125}
126
127/// Default dirs path.
128pub fn default_model_search_paths() -> Vec<String> {
129    let mut paths = Vec::new();
130    for env_key in ["QUALIA_LLM_VAULT", "QUALIA_MODEL_PATHS"] {
131        if let Some(val) = std::env::var_os(env_key) {
132            for p in std::env::split_paths(&val) {
133                if !p.as_os_str().is_empty() {
134                    paths.push(p.to_string_lossy().into_owned());
135                }
136            }
137        }
138    }
139    #[cfg(target_os = "windows")]
140    {
141        for candidate in [r"C:\LLM_files", r"C:\LLM_Models"] {
142            if !paths.iter().any(|p| p.eq_ignore_ascii_case(candidate)) {
143                paths.push(candidate.to_string());
144            }
145        }
146    }
147    paths
148}
149
150pub fn dirs_default_path() -> String {
151    #[cfg(target_os = "windows")]
152    {
153        std::env::var("LOCALAPPDATA")
154            .map(|d| format!("{}\\QualiaData", d))
155            .unwrap_or_else(|_| "C:\\QualiaData".to_string())
156    }
157    #[cfg(target_os = "macos")]
158    {
159        std::env::var("HOME")
160            .map(|h| format!("{}/Library/Application Support/QualiaData", h))
161            .unwrap_or_else(|_| "/tmp/QualiaData".to_string())
162    }
163    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
164    {
165        std::env::var("HOME")
166            .map(|h| format!("{}/.local/share/QualiaData", h))
167            .unwrap_or_else(|_| "/tmp/QualiaData".to_string())
168    }
169}
170
171/// App metadata dir.
172pub fn app_meta_dir() -> PathBuf {
173    // Tests and multi-profile installs may override the meta root without changing code.
174    if let Ok(p) = std::env::var("QUALIA_APP_META_DIR") {
175        let trimmed = p.trim();
176        if !trimmed.is_empty() {
177            return PathBuf::from(trimmed);
178        }
179    }
180    #[cfg(target_os = "windows")]
181    {
182        PathBuf::from(
183            std::env::var("LOCALAPPDATA")
184                .unwrap_or_else(|_| "C:\\Users\\Default\\AppData\\Local".to_string()),
185        )
186        .join("Qualia")
187    }
188    #[cfg(target_os = "macos")]
189    {
190        PathBuf::from(std::env::var("HOME").unwrap_or_default())
191            .join("Library/Application Support/Qualia")
192    }
193    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
194    {
195        PathBuf::from(std::env::var("HOME").unwrap_or_default()).join(".config/qualia")
196    }
197}
198
199/// Config file path.
200pub fn config_file_path() -> PathBuf {
201    app_meta_dir().join("config.json")
202}
203/// Identity file path.
204pub fn identity_file_path() -> PathBuf {
205    app_meta_dir().join("identity.json")
206}
207
208/// Loads config-from-disk.
209pub fn load_config_from_disk() -> AgentConfig {
210    std::fs::read_to_string(config_file_path())
211        .ok()
212        .and_then(|s| serde_json::from_str(&s).ok())
213        .unwrap_or_else(AgentConfig::default)
214}
215
216/// Initializes data directories.
217pub fn init_data_directories(storage_path: &str) {
218    let base = PathBuf::from(storage_path);
219    for sub in &[
220        "Models",
221        "Index",
222        "qapps",
223        "library",
224        "ontologies",
225        "qlinks",
226        "SemanticLibrary",
227        "Identity",
228        "Chats",
229    ] {
230        let _ = std::fs::create_dir_all(base.join(sub));
231    }
232}
233
234// ── App state ─────────────────────────────────────────────────────────────────
235
236#[derive(Clone, Serialize, Deserialize)]
237pub struct ProgressPayload {
238    pub id: String,
239    pub progress: f64,
240    pub downloaded_bytes: u64,
241    pub total_bytes: u64,
242    pub speed_kbps: f64,
243    pub status: String,
244}
245
246pub struct AppState {
247    pub config: Mutex<AgentConfig>,
248    pub tax_suite: Mutex<TaxRecipientSuite>,
249    pub daemon_running: Arc<Mutex<bool>>,
250    pub nym_relay_active: Arc<AtomicBool>,
251    pub stark_prover_active: Arc<AtomicBool>,
252    pub simulated_solar_watts: Arc<AtomicU32>,
253    pub download_handles: Arc<Mutex<HashMap<String, Arc<AtomicBool>>>>,
254    pub active_downloads: Arc<Mutex<HashMap<String, ProgressPayload>>>,
255    pub active_model: Arc<Mutex<Option<String>>>,
256    // pub rqbit_session: Arc<tokio::sync::Mutex<Option<std::sync::Arc<librqbit::Session>>>>,
257    pub directory_actors: Arc<Mutex<Vec<Actor>>>,
258    pub delegation_rules: Arc<Mutex<Vec<DelegationRule>>>,
259    pub front_doors: Arc<Mutex<Vec<FrontDoor>>>,
260    pub installed_qapps: Arc<Mutex<Vec<qapp_registry::RegisteredQapp>>>,
261    pub key_vault: Arc<Mutex<qualia_core_db::key_vault::KeyVault>>,
262    pub download_events: tokio::sync::broadcast::Sender<ProgressPayload>,
263}
264
265#[derive(Clone, Serialize, Deserialize)]
266pub struct FrontDoor {
267    pub id: String,
268    pub did_uri: String,
269    pub label: String,
270    pub created_at: String,
271    pub routing_hints: Vec<String>,
272}
273
274#[derive(Clone, Serialize, Deserialize)]
275pub struct Actor {
276    pub id: String,
277    pub actor_type: String,
278    pub name: String,
279    pub organization: Option<String>,
280    pub qualifications: Vec<String>,
281    pub roles: Vec<String>,
282    pub verification_status: String,
283    pub pairwise_did: String,
284    pub root_did_uri: Option<String>,
285    pub routing_hints: Vec<String>,
286}
287
288#[derive(Clone, Serialize, Deserialize)]
289pub struct DelegationRule {
290    pub id: String,
291    pub actor_id: String,
292    pub granted_roles: Vec<String>,
293    pub legal_basis: String,
294    pub privacy_mode_limit: String,
295    pub allowed_record_types: Vec<String>,
296    pub restricted_records: Vec<String>,
297    pub is_active: bool,
298}
299
300/// Suite file path.
301pub fn suite_file_path(data_dir: &str) -> PathBuf {
302    PathBuf::from(data_dir).join("tax_suite.json")
303}
304
305/// Loads suite-from-disk.
306pub fn load_suite_from_disk(data_dir: &str) -> TaxRecipientSuite {
307    let path = suite_file_path(data_dir);
308    std::fs::read_to_string(&path)
309        .ok()
310        .and_then(|s| serde_json::from_str(&s).ok())
311        .unwrap_or_else(TaxRecipientSuite::default_cooperative)
312}