qualia_client_core/api/
dashboard.rs1#![allow(non_snake_case)]
4
5use super::*;
6
7use crate::qapp_registry;
8use crate::state::*;
9
10pub fn run_engine_command(cmd: String) -> String {
12 match cmd.as_str() {
13 "ingest_bench" => profile_energy_circumstance(),
14 "zk_screen" => format!(
15 "Daemon: {} | Ollama: {}",
16 daemon_status(),
17 check_ollama_status()
18 ),
19 _ => "Unknown command".to_string(),
20 }
21}
22
23pub fn toggle_window() {
27 }
29
30#[derive(Clone, serde::Serialize, serde::Deserialize)]
35pub struct DirectoryState {
36 pub actors: Vec<Actor>,
37 pub rules: Vec<DelegationRule>,
38 pub front_doors: Vec<FrontDoor>,
39 pub installed_qapps: Vec<qapp_registry::RegisteredQapp>,
40}
41
42#[derive(Clone, serde::Serialize, serde::Deserialize)]
43pub struct SignedDirectoryState {
44 pub state: DirectoryState,
45 pub signature_hex: String,
46}
47
48pub fn save_directory_state() {
50 let state = crate::state::APP_STATE.get().unwrap();
51 let home = std::env::var("USERPROFILE").unwrap_or_else(|_| "C:\\".to_string());
52 let qualia_dir = std::path::PathBuf::from(home).join(".qualia");
53 if !qualia_dir.exists() {
54 let _ = std::fs::create_dir_all(&qualia_dir);
55 }
56
57 let ds = DirectoryState {
58 actors: state.directory_actors.lock().unwrap().clone(),
59 rules: state.delegation_rules.lock().unwrap().clone(),
60 front_doors: state.front_doors.lock().unwrap().clone(),
61 installed_qapps: state.installed_qapps.lock().unwrap().clone(),
62 };
63
64 let payload = serde_json::to_string(&ds).unwrap();
65 let vault = state.key_vault.lock().unwrap();
66 let sig = vault.sign_payload(&vault.derive_key("persistence"), payload.as_bytes());
69 let sig_hex = hex::encode(sig.to_bytes());
70
71 let signed_state = SignedDirectoryState {
72 state: ds,
73 signature_hex: sig_hex,
74 };
75
76 let state_path = qualia_dir.join("directory_state.json");
77 let _ = std::fs::write(
78 &state_path,
79 serde_json::to_string_pretty(&signed_state).unwrap(),
80 );
81}
82
83pub fn load_directory_state(vault: &qualia_core_db::key_vault::KeyVault) -> DirectoryState {
85 let home = std::env::var("USERPROFILE").unwrap_or_else(|_| "C:\\".to_string());
86 let state_path = std::path::PathBuf::from(home)
87 .join(".qualia")
88 .join("directory_state.json");
89
90 if state_path.exists() {
91 if let Ok(content) = std::fs::read_to_string(&state_path) {
92 if let Ok(signed_state) = serde_json::from_str::<SignedDirectoryState>(&content) {
93 let payload = serde_json::to_string(&signed_state.state).unwrap();
94 let sig_bytes = hex::decode(&signed_state.signature_hex).unwrap_or_default();
95 if sig_bytes.len() == 64 {
96 let mut sig_arr = [0u8; 64];
97 sig_arr.copy_from_slice(&sig_bytes);
98 let persistence_key = vault.derive_key("persistence");
99 let pk = ed25519_dalek::VerifyingKey::from(&persistence_key);
100 if qualia_core_db::key_vault::KeyVault::verify_signature(
101 pk.as_bytes(),
102 payload.as_bytes(),
103 &sig_arr,
104 )
105 .is_ok()
106 {
107 return signed_state.state;
108 } else {
109 eprintln!("WARNING: directory_state.json signature validation failed! Tampering detected.");
110 }
111 }
112 }
113 }
114 }
115
116 DirectoryState {
117 actors: Vec::new(),
118 rules: Vec::new(),
119 front_doors: Vec::new(),
120 installed_qapps: Vec::new(),
121 }
122}
123
124pub fn get_front_doors() -> Result<Vec<FrontDoor>, String> {
126 let state = crate::state::APP_STATE.get().unwrap();
127 let doors = state.front_doors.lock().unwrap().clone();
128 Ok(doors)
129}
130
131pub fn generate_front_door(label: String) -> Result<FrontDoor, String> {
133 let state = crate::state::APP_STATE.get().unwrap();
134 use std::time::{SystemTime, UNIX_EPOCH};
135 let now = SystemTime::now()
136 .duration_since(UNIX_EPOCH)
137 .unwrap()
138 .as_millis();
139
140 let vault = state.key_vault.lock().unwrap();
141 let fd_id = format!("fd-{}", now);
142 let derived_key = vault.derive_key(&fd_id);
143 let pub_key_hex = hex::encode(ed25519_dalek::VerifyingKey::from(&derived_key).as_bytes());
144 let did_uri = format!("did:qualia:frontdoor:{}", pub_key_hex);
145
146 let door = FrontDoor {
150 id: fd_id,
151 did_uri,
152 label,
153 created_at: now.to_string(),
154 routing_hints: vec![],
155 };
156
157 drop(vault);
158 state.front_doors.lock().unwrap().push(door.clone());
159 save_directory_state();
160 Ok(door)
161}
162
163pub fn get_directory_actors() -> Result<Vec<Actor>, String> {
165 let state = crate::state::APP_STATE.get().unwrap();
166 let actors = state.directory_actors.lock().unwrap().clone();
167 Ok(actors)
168}
169
170pub fn add_directory_actor(actor: Actor) -> Result<(), String> {
172 let state = crate::state::APP_STATE.get().unwrap();
173 state.directory_actors.lock().unwrap().push(actor);
174 save_directory_state();
175 Ok(())
176}
177
178pub fn get_delegation_rules() -> Result<Vec<DelegationRule>, String> {
180 let state = crate::state::APP_STATE.get().unwrap();
181 let rules = state.delegation_rules.lock().unwrap().clone();
182 Ok(rules)
183}
184
185pub fn add_delegation_rule(rule: DelegationRule) -> Result<(), String> {
187 let state = crate::state::APP_STATE.get().unwrap();
188 state.delegation_rules.lock().unwrap().push(rule);
189 save_directory_state();
190 Ok(())
191}