Skip to main content

qualia_client_core/api/
dashboard.rs

1//! Dashboard engine command
2
3#![allow(non_snake_case)]
4
5use super::*;
6
7use crate::qapp_registry;
8use crate::state::*;
9
10/// Runs an engine command.
11pub 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
23// Tray functionality removed with Tauri
24
25/// Toggles window.
26pub fn toggle_window() {
27    // No-op without Tauri
28}
29
30// ─────────────────────────────────────────────────────────────────────────────
31// Agent Directory & Delegation Manager
32// ─────────────────────────────────────────────────────────────────────────────
33
34#[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
48/// Saves directory-state.
49pub 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    // Since we don't have the derived key in scope here easily, we sign with master for persistence.
67    // In a real implementation, we'd sign with the specific identity.
68    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
83/// Loads directory-state.
84pub 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
124/// Gets front-doors.
125pub 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
131/// Generates the front door.
132pub 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    // Optional: Pre-generate the WebID-TLS cert here if needed
147    // let (cert, _) = vault.generate_webid_tls_cert(&derived_key, &did_uri).unwrap();
148
149    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
163/// Gets directory-actors.
164pub 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
170/// Adds directory-actor.
171pub 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
178/// Gets delegation-rules.
179pub 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
185/// Adds delegation-rule.
186pub 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}