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
11pub 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 let _ = crate::identity_plane::ensure_local_apparatus(None);
26 state
27}
28
29#[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 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#[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 pub settings_port: u16,
107 #[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
127pub 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
171pub fn app_meta_dir() -> PathBuf {
173 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
199pub fn config_file_path() -> PathBuf {
201 app_meta_dir().join("config.json")
202}
203pub fn identity_file_path() -> PathBuf {
205 app_meta_dir().join("identity.json")
206}
207
208pub 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
216pub 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#[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 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
300pub fn suite_file_path(data_dir: &str) -> PathBuf {
302 PathBuf::from(data_dir).join("tax_suite.json")
303}
304
305pub 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}