1use std::sync::Arc;
16
17use dashmap::DashMap;
18use tokio::sync::{broadcast, mpsc, Mutex};
19use trustee_core::session::Session;
20use trustee_core::types::TuiMessage;
21
22use crate::auth::AuthState;
23
24tokio::task_local! {
29 static USER_KEY_OVERRIDE: String;
37}
38
39pub(crate) fn effective_user_key(user_key: &str) -> String {
42 USER_KEY_OVERRIDE
43 .try_with(|v| v.clone())
44 .unwrap_or_else(|_| user_key.to_string())
45}
46
47pub(crate) async fn in_dispatch_scope<F: std::future::Future>(user_key: &str, fut: F) -> F::Output {
50 USER_KEY_OVERRIDE.scope(user_key.to_string(), fut).await
51}
52
53pub fn apply_home_links() -> Vec<String> {
63 let Some(home) = dirs::home_dir() else {
64 return Vec::new();
65 };
66 let users = home.join(".trustee").join("users");
67 let map_path = users.join("home_links.json");
68 let Ok(text) = std::fs::read_to_string(&map_path) else {
69 return Vec::new();
70 };
71 let Ok(doc) = serde_json::from_str::<serde_json::Value>(&text) else {
72 tracing::warn!(
73 "home_links.json is not valid JSON — ignored: {}",
74 map_path.display()
75 );
76 return Vec::new();
77 };
78 let mut report = Vec::new();
79 if let Some(links) = doc.get("links").and_then(|v| v.as_array()) {
80 for l in links {
81 let (Some(from), Some(to)) = (
82 l.get("from_hash").and_then(|v| v.as_str()),
83 l.get("to_hash").and_then(|v| v.as_str()),
84 ) else {
85 continue;
86 };
87 let from_dir = users.join(from);
88 let to_dir = users.join(to);
89 if !from_dir.exists() {
90 continue; }
92 if to_dir.exists() {
93 let empty = std::fs::read_dir(&to_dir)
94 .map(|it| it.count() == 0)
95 .unwrap_or(false);
96 if !empty {
97 let msg = format!(
98 "home link {from} → {to}: target exists with content — NOT touched, reconcile manually"
99 );
100 tracing::warn!("home_links: {msg}");
101 report.push(msg);
102 continue;
103 }
104 let _ = std::fs::remove_dir(&to_dir);
105 }
106 match std::fs::rename(&from_dir, &to_dir) {
107 Ok(()) => {
108 let msg =
109 format!("home link applied: {from} → {to} (config/sessions restored)");
110 tracing::info!("home_links: {msg}");
111 report.push(msg);
112 }
113 Err(e) => {
114 let msg = format!("home link {from} → {to} FAILED: {e}");
115 tracing::warn!("home_links: {msg}");
116 report.push(msg);
117 }
118 }
119 }
120 }
121 report
122}
123
124pub struct UserSessionEntry {
130 pub session: Arc<Mutex<Session>>,
132 pub ws_tx: broadcast::Sender<String>,
134 pub created_at: chrono::DateTime<chrono::Utc>,
136 pub last_active: Arc<Mutex<chrono::DateTime<chrono::Utc>>>,
139 pub drain_abort: Option<tokio::task::AbortHandle>,
148}
149
150pub struct UserSessions {
152 pub sessions: DashMap<String, UserSessionEntry>,
154 pub token_store: Arc<pep::MemoryTokenStore>,
156}
157
158#[derive(Debug, serde::Serialize)]
160pub struct SessionListItem {
161 pub session_id: String,
162 pub session_name: Option<String>,
163 pub workflow_state: String,
164 pub created_at: String,
165 pub last_active: String,
166 pub handoff_count: u32,
171}
172
173#[derive(Debug)]
175pub enum SessionError {
176 MaxSessionsReached(usize),
178 NotFound(String),
180 NotIdle(String),
182}
183
184impl std::fmt::Display for SessionError {
185 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
186 match self {
187 SessionError::MaxSessionsReached(n) => {
188 write!(f, "Maximum {} sessions per user reached", n)
189 }
190 SessionError::NotFound(id) => write!(f, "Session {} not found", id),
191 SessionError::NotIdle(state) => write!(f, "Session is not idle (state: {})", state),
192 }
193 }
194}
195
196impl std::error::Error for SessionError {}
197
198pub type SessionRegistry = Arc<DashMap<String, UserSessions>>;
200
201pub struct McpLoaderEntry {
212 pub loader: Option<std::sync::Arc<abk::agent::McpToolLoader>>,
214 pub fingerprint: u64,
217 pub built_at: chrono::DateTime<chrono::Utc>,
218 pub degraded: Option<String>,
221 pub failed_at: Option<chrono::DateTime<chrono::Utc>>,
224}
225
226pub const MCP_BUILD_RETRY_BACKOFF: std::time::Duration = std::time::Duration::from_secs(30);
228
229pub const MCP_TOOLSET_MAX_AGE: std::time::Duration = std::time::Duration::from_secs(600);
239
240#[derive(Debug, Clone, PartialEq, Eq)]
242pub(crate) enum LoaderFreshness {
243 Fresh,
245 ConfigChanged,
247 AgedOut,
251 Backoff(std::time::Duration),
253}
254
255pub(crate) fn loader_freshness(
258 entry_fingerprint: u64,
259 entry_built_at: chrono::DateTime<chrono::Utc>,
260 entry_degraded: Option<&str>,
261 entry_failed_at: Option<chrono::DateTime<chrono::Utc>>,
262 wanted_fingerprint: u64,
263 now: chrono::DateTime<chrono::Utc>,
264) -> LoaderFreshness {
265 if entry_degraded.is_some() {
268 if let Some(failed_at) = entry_failed_at {
269 let backoff = chrono::Duration::from_std(MCP_BUILD_RETRY_BACKOFF)
270 .unwrap_or_else(|_| chrono::Duration::seconds(30));
271 if now < failed_at + backoff {
272 return LoaderFreshness::Backoff(
273 (failed_at + backoff - now).to_std().unwrap_or_default(),
274 );
275 }
276 }
277 }
278 if wanted_fingerprint != entry_fingerprint {
279 return LoaderFreshness::ConfigChanged;
280 }
281 let max_age = chrono::Duration::from_std(MCP_TOOLSET_MAX_AGE)
282 .unwrap_or_else(|_| chrono::Duration::seconds(600));
283 if now > entry_built_at + max_age {
284 LoaderFreshness::AgedOut
285 } else {
286 LoaderFreshness::Fresh
287 }
288}
289
290#[derive(Debug, Clone)]
297pub struct ThqDispatchEntry {
298 pub user_key: String,
303 pub service_token: Option<String>,
307 pub issuer_url: Option<String>,
313}
314
315pub fn service_issuers_from_config(config_toml: &str) -> Vec<String> {
319 let Ok(v) = config_toml.parse::<toml::Value>() else {
320 return Vec::new();
321 };
322 let Some(creds) = v
323 .get("mcp")
324 .and_then(|m| m.get("credentials"))
325 .and_then(|c| c.as_table())
326 else {
327 return Vec::new();
328 };
329 let mut out = Vec::new();
330 for (_name, cred) in creds {
331 if cred.get("type").and_then(|t| t.as_str()) == Some("service-account") {
332 if let Some(issuer) = cred.get("issuer_url").and_then(|i| i.as_str()) {
333 if !out.iter().any(|e: &String| e == issuer) {
334 out.push(issuer.to_string());
335 }
336 }
337 }
338 }
339 out
340}
341
342#[derive(Clone)]
344pub struct ServerState {
345 pub sessions: SessionRegistry,
347 pub ws_tx: broadcast::Sender<String>,
349 pub auth: Option<Arc<AuthState>>,
351 pub config_toml: Option<String>,
353 pub secrets: Option<std::collections::HashMap<String, String>>,
355 pub build_info: Option<trustee_core::types::BuildInfo>,
357 pub workflow_semaphore: Arc<tokio::sync::Semaphore>,
360 pub max_sessions_per_user: usize,
362 pub allow_llm_overlay: bool,
365 pub mcp_loaders: Arc<DashMap<String, McpLoaderEntry>>,
367 mcp_build_locks: Arc<DashMap<String, Arc<tokio::sync::Mutex<()>>>>,
369 pub thq_dispatch: Arc<DashMap<String, ThqDispatchEntry>>,
371 pub agent_dispatch_tokens: Arc<DashMap<String, (String, std::time::Instant)>>,
379}
380
381impl ServerState {
382 pub fn new(
384 session: Session,
385 ws_tx: broadcast::Sender<String>,
386 auth: Option<Arc<AuthState>>,
387 ) -> Self {
388 apply_home_links();
391
392 let sessions = Arc::new(DashMap::new());
393
394 let token_store = Arc::new(pep::MemoryTokenStore::new());
396 let (ws_tx_entry, _) = broadcast::channel::<String>(256);
397
398 let now = chrono::Utc::now();
399 let initial_entry = UserSessionEntry {
400 session: Arc::new(Mutex::new(session)),
401 ws_tx: ws_tx_entry,
402 created_at: now,
403 last_active: Arc::new(Mutex::new(now)),
404 drain_abort: None,
405 };
406
407 let user_sessions = UserSessions {
408 sessions: DashMap::new(),
409 token_store,
410 };
411 user_sessions
412 .sessions
413 .insert("default".to_string(), initial_entry);
414
415 sessions.insert("default".to_string(), user_sessions);
416
417 Self {
418 sessions,
419 ws_tx,
420 auth,
421 config_toml: None,
422 secrets: None,
423 build_info: None,
424 workflow_semaphore: Arc::new(tokio::sync::Semaphore::new(8)),
425 max_sessions_per_user: 4,
426 allow_llm_overlay: false,
427 mcp_loaders: Arc::new(DashMap::new()),
428 mcp_build_locks: Arc::new(DashMap::new()),
429 thq_dispatch: Arc::new(DashMap::new()),
430 agent_dispatch_tokens: Arc::new(DashMap::new()),
431 }
432 }
433
434 pub fn with_config_toml(mut self, config_toml: String) -> Self {
435 let model = config_toml
442 .parse::<toml::Value>()
443 .ok()
444 .and_then(|v| {
445 v.get("llm")
446 .and_then(|l| l.get("provider"))
447 .and_then(|p| p.get("model"))
448 .and_then(|m| m.as_str())
449 .map(|s| s.trim().to_string())
450 })
451 .unwrap_or_default();
452 if model.is_empty() {
453 tracing::warn!(
454 "[llm.provider].model is missing or empty — LLM calls will fail with 'no model configured: set [llm.provider].model or OPENAI_DEFAULT_MODEL' until set (THQ-runtime instances that never serve LLM sessions may ignore this)"
455 );
456 }
457 self.config_toml = Some(config_toml);
458 self
459 }
460
461 pub fn service_issuers(&self) -> Vec<String> {
472 service_issuers_from_config(self.config_toml.as_deref().unwrap_or(""))
473 }
474
475 pub fn with_secrets(mut self, secrets: std::collections::HashMap<String, String>) -> Self {
476 self.secrets = Some(secrets);
477 self
478 }
479
480 pub fn with_build_info(mut self, build_info: trustee_core::types::BuildInfo) -> Self {
481 self.build_info = Some(build_info);
482 self
483 }
484
485 pub fn with_max_concurrent_workflows(mut self, max: usize) -> Self {
486 self.workflow_semaphore = Arc::new(tokio::sync::Semaphore::new(max));
487 self
488 }
489
490 pub fn with_max_sessions_per_user(mut self, max: usize) -> Self {
492 self.max_sessions_per_user = max;
493 self
494 }
495
496 pub fn with_allow_llm_overlay(mut self, allow: bool) -> Self {
499 self.allow_llm_overlay = allow;
500 self
501 }
502
503 pub async fn create_session(
526 &self,
527 user_key: &str,
528 session_name: Option<String>,
529 identity: Option<String>,
530 ) -> Result<String, SessionError> {
531 let user_sessions = self
533 .sessions
534 .entry(user_key.to_string())
535 .or_insert_with(|| UserSessions {
536 sessions: DashMap::new(),
537 token_store: Arc::new(pep::MemoryTokenStore::new()),
538 });
539
540 if user_sessions.sessions.len() >= self.max_sessions_per_user {
542 return Err(SessionError::MaxSessionsReached(self.max_sessions_per_user));
543 }
544
545 let (mut session, workflow_rx) = Session::new();
547
548 if let Some(ref config_toml) = self.config_toml {
550 session.config_toml = Some(config_toml.clone());
551 session.parse_auto_handoff_config();
552 if let Ok(table) = config_toml.parse::<toml::Value>() {
553 if let Some(name) = table
554 .get("agent")
555 .and_then(|a| a.get("name"))
556 .and_then(|n| n.as_str())
557 {
558 session.agent_name = name.to_string();
559 }
560 }
561 }
562
563 session.secrets = self.secrets.clone();
564 session.build_info = self.build_info.clone();
565
566 self.apply_user_isolation(&mut session, user_key);
568
569 session.session_name = session_name;
571
572 session.identity = identity;
574
575 let (ws_tx_entry, _) = broadcast::channel::<String>(256);
577
578 let session_id = format!(
580 "session_{}_{}",
581 chrono::Utc::now().format("%Y_%m_%d_%H_%M"),
582 &uuid::Uuid::new_v4().to_string()[..8]
583 );
584
585 session.session_id = Some(session_id.clone());
591
592 let now = chrono::Utc::now();
593
594 user_sessions.sessions.insert(
596 session_id.clone(),
597 UserSessionEntry {
598 session: Arc::new(Mutex::new(session)),
599 ws_tx: ws_tx_entry.clone(),
600 created_at: now,
601 last_active: Arc::new(Mutex::new(now)),
602 drain_abort: None,
603 },
604 );
605
606 let session_arc = user_sessions
608 .sessions
609 .get(&session_id)
610 .map(|e| e.session.clone());
611 if let Some(session_arc) = session_arc {
612 let handle =
613 self.spawn_user_drain_task(session_id.clone(), session_arc, ws_tx_entry, workflow_rx);
614 if let Some(mut e) = user_sessions.sessions.get_mut(&session_id) {
618 e.drain_abort = Some(handle.abort_handle());
619 }
620 }
621
622 Ok(session_id)
623 }
624
625 pub async fn get_session(
628 &self,
629 user_key: &str,
630 session_id: &str,
631 ) -> Option<(Arc<Mutex<Session>>, broadcast::Sender<String>)> {
632 let user_sessions = self.sessions.get(user_key)?;
633 let entry = user_sessions.sessions.get(session_id)?;
634
635 let now = chrono::Utc::now();
637 *entry.last_active.lock().await = now;
638
639 Some((entry.session.clone(), entry.ws_tx.clone()))
640 }
641
642 pub async fn get_session_by_any_id(
660 &self,
661 user_key: &str,
662 id: &str,
663 ) -> Option<(String, Arc<Mutex<Session>>, broadcast::Sender<String>)> {
664 let user_sessions = self.sessions.get(user_key)?;
666 if let Some(entry) = user_sessions.sessions.get(id) {
667 let now = chrono::Utc::now();
669 *entry.last_active.lock().await = now;
670 return Some((id.to_string(), entry.session.clone(), entry.ws_tx.clone()));
671 }
672
673 for entry in user_sessions.sessions.iter() {
675 let session = entry.session.lock().await;
676 if session.session_id.as_deref() == Some(id) {
677 let key = entry.key().clone();
678 let ws_tx = entry.ws_tx.clone();
679 drop(session);
680 let now = chrono::Utc::now();
682 *entry.last_active.lock().await = now;
683 return Some((key, entry.session.clone(), ws_tx));
684 }
685 }
686
687 None
688 }
689
690 fn tombstone_path(&self, user_key: &str, chain_id: &str) -> Option<std::path::PathBuf> {
699 if chain_id.is_empty() || !chain_id.starts_with("session_") {
700 return None;
701 }
702 let user_key = effective_user_key(user_key);
703 let hash = trustee_core::user_hash(&user_key);
704 dirs::home_dir().map(|home| {
705 home.join(".trustee")
706 .join("users")
707 .join(&hash)
708 .join("session_tombstones")
709 .join(chain_id)
710 })
711 }
712
713 fn write_tombstone(&self, user_key: &str, chain_id: &str) {
718 if let Some(path) = self.tombstone_path(user_key, chain_id) {
719 if let Some(parent) = path.parent() {
720 let _ = std::fs::create_dir_all(parent);
721 }
722 let _ = std::fs::write(&path, chrono::Utc::now().to_rfc3339());
723 }
724 }
725
726 pub fn chain_tombstone_stamp(&self, user_key: &str, chain_id: &str) -> Option<String> {
734 let path = self.tombstone_path(user_key, chain_id)?;
735 let text = std::fs::read_to_string(&path).ok()?;
736 let trimmed = text.trim();
737 if trimmed.is_empty() {
738 None
739 } else {
740 Some(trimmed.to_string())
741 }
742 }
743
744 pub async fn get_or_restore_session_by_any_id(
758 &self,
759 user_key: &str,
760 id: &str,
761 ) -> Option<(String, Arc<Mutex<Session>>, broadcast::Sender<String>)> {
762 if let Some(found) = self.get_session_by_any_id(user_key, id).await {
763 return Some(found);
764 }
765 self.restore_session_from_checkpoint(user_key, id).await
766 }
767
768 async fn restore_session_from_checkpoint(
777 &self,
778 user_key: &str,
779 chain_id: &str,
780 ) -> Option<(String, Arc<Mutex<Session>>, broadcast::Sender<String>)> {
781 if let Some(path) = self.tombstone_path(user_key, chain_id) {
783 if path.exists() {
784 return None;
785 }
786 }
787
788 let (config_toml, home_dir) = self.get_user_config_and_home(user_key);
790 let config_toml = config_toml?;
791
792 let info = match trustee_core::sessions::create_resume_info(
803 &config_toml,
804 chain_id,
805 home_dir.as_deref(),
806 )
807 .await
808 .ok()
809 .flatten()
810 {
811 Some(info) => info,
812 None => {
813 let source = trustee_core::sessions::resolve_resume_handle(
814 &config_toml,
815 chain_id,
816 home_dir.as_deref(),
817 )
818 .await
819 .ok()
820 .flatten()?;
821 trustee_core::sessions::create_resume_info(
822 &config_toml,
823 &source,
824 home_dir.as_deref(),
825 )
826 .await
827 .ok()
828 .flatten()?
829 }
830 };
831
832 let user_sessions = self
835 .sessions
836 .entry(user_key.to_string())
837 .or_insert_with(|| UserSessions {
838 sessions: DashMap::new(),
839 token_store: Arc::new(pep::MemoryTokenStore::new()),
840 });
841
842 if let Some(existing) = user_sessions.sessions.get(chain_id) {
843 let now = chrono::Utc::now();
844 *existing.last_active.lock().await = now;
845 return Some((
846 chain_id.to_string(),
847 existing.session.clone(),
848 existing.ws_tx.clone(),
849 ));
850 }
851
852 if user_sessions.sessions.len() >= self.max_sessions_per_user {
857 let mut evict: Option<(String, chrono::DateTime<chrono::Utc>)> = None;
858 for entry in user_sessions.sessions.iter() {
859 let is_idle = entry.session.lock().await.workflow_state
860 == trustee_core::types::WorkflowState::Idle;
861 if !is_idle {
862 continue;
863 }
864 let la = entry.last_active.lock().await;
865 if evict.as_ref().is_none_or(|(_, t)| *la < *t) {
866 evict = Some((entry.key().clone(), *la));
867 }
868 }
869 if let Some((victim, _)) = evict {
870 if let Some(mut v) = user_sessions.sessions.get_mut(&victim) {
874 if let Some(handle) = v.drain_abort.take() {
875 handle.abort();
876 }
877 }
878 user_sessions.sessions.remove(&victim);
879 } else {
880 return None;
881 }
882 }
883
884 let (mut session, workflow_rx) = Session::new();
887 session.config_toml = Some(config_toml.clone());
888 session.parse_auto_handoff_config();
889 if let Ok(table) = config_toml.parse::<toml::Value>() {
890 if let Some(name) = table
891 .get("agent")
892 .and_then(|a| a.get("name"))
893 .and_then(|n| n.as_str())
894 {
895 session.agent_name = name.to_string();
896 }
897 }
898 session.secrets = self.secrets.clone();
899 session.build_info = self.build_info.clone();
900 self.apply_user_isolation(&mut session, user_key);
901 session.session_id = Some(chain_id.to_string());
902 session.resume_info = Some(info);
903 session.session_name = None; let (ws_tx_entry, _) = broadcast::channel::<String>(256);
906 let now = chrono::Utc::now();
907
908 user_sessions.sessions.insert(
909 chain_id.to_string(),
910 UserSessionEntry {
911 session: Arc::new(Mutex::new(session)),
912 ws_tx: ws_tx_entry.clone(),
913 created_at: now,
914 last_active: Arc::new(Mutex::new(now)),
915 drain_abort: None,
916 },
917 );
918
919 let session_arc = user_sessions
923 .sessions
924 .get(chain_id)
925 .map(|e| e.session.clone())
926 .ok_or_else(|| SessionError::NotFound(chain_id.to_string()))
927 .ok()?;
928 let handle = self.spawn_user_drain_task(
929 chain_id.to_string(),
930 session_arc.clone(),
931 ws_tx_entry.clone(),
932 workflow_rx,
933 );
934 if let Some(mut e) = user_sessions.sessions.get_mut(chain_id) {
938 e.drain_abort = Some(handle.abort_handle());
939 }
940
941 Some((chain_id.to_string(), session_arc, ws_tx_entry))
942 }
943
944 pub async fn list_sessions(&self, user_key: &str) -> Vec<SessionListItem> {
946 let Some(user_sessions) = self.sessions.get(user_key) else {
947 return Vec::new();
948 };
949
950 let mut items = Vec::new();
951 for entry in user_sessions.sessions.iter() {
952 let session = entry.session.lock().await;
953 let workflow_state = match session.workflow_state {
954 trustee_core::types::WorkflowState::Idle => "Idle",
955 trustee_core::types::WorkflowState::Running => "Running",
956 trustee_core::types::WorkflowState::Cancelling => "Cancelling",
957 };
958 let last_active = entry.last_active.lock().await;
959 items.push(SessionListItem {
960 session_id: entry.key().clone(),
961 session_name: session.session_name.clone(),
962 workflow_state: workflow_state.to_string(),
963 created_at: entry.created_at.to_rfc3339(),
964 last_active: last_active.to_rfc3339(),
965 handoff_count: session.handoff_count,
966 });
967 }
968 drop(user_sessions);
969
970 items.sort_by(|a, b| b.last_active.cmp(&a.last_active));
972 items
973 }
974
975 pub async fn destroy_session(
977 &self,
978 user_key: &str,
979 session_id: &str,
980 ) -> Result<(), SessionError> {
981 let user_sessions = self
982 .sessions
983 .get(user_key)
984 .ok_or_else(|| SessionError::NotFound(session_id.to_string()))?;
985
986 let chain_id_for_tombstone = {
989 let entry = user_sessions
990 .sessions
991 .get(session_id)
992 .ok_or_else(|| SessionError::NotFound(session_id.to_string()))?;
993 let session = entry.session.lock().await;
994 if session.workflow_state != trustee_core::types::WorkflowState::Idle {
995 let state_str = match session.workflow_state {
996 trustee_core::types::WorkflowState::Running => "Running",
997 trustee_core::types::WorkflowState::Cancelling => "Cancelling",
998 _ => "Unknown",
999 };
1000 return Err(SessionError::NotIdle(state_str.to_string()));
1001 }
1002 session.session_id.clone()
1003 };
1004
1005 if let Some(mut entry) = user_sessions.sessions.get_mut(session_id) {
1015 if let Some(handle) = entry.drain_abort.take() {
1016 handle.abort();
1017 }
1018 }
1019
1020 user_sessions.sessions.remove(session_id);
1022
1023 if let Some(chain_id) = chain_id_for_tombstone {
1027 self.write_tombstone(user_key, &chain_id);
1028 }
1029
1030 Ok(())
1031 }
1032
1033 pub fn get_user_home_dir(&self, user_key: &str) -> Option<std::path::PathBuf> {
1044 if std::env::var("TRUSTEE_CLASSIC_HOME").as_deref() == Ok("1") {
1055 static GATE_WARNED: std::sync::Once = std::sync::Once::new();
1056 GATE_WARNED.call_once(|| {
1057 tracing::warn!(
1058 "TRUSTEE_CLASSIC_HOME=1 — ALL users share the classic home \
1059 (~/.trustee); per-user checkpoint isolation is OFF. \
1060 Single-user loopback ONLY — unset this env on multi-user servers."
1061 );
1062 });
1063 return dirs::home_dir().map(|home| home.join(".trustee"));
1064 }
1065 let user_key = effective_user_key(user_key);
1066 let hash = trustee_core::user_hash(&user_key);
1067 dirs::home_dir().map(|home| home.join(".trustee").join("users").join(&hash))
1068 }
1069
1070 pub fn get_user_config_and_home(
1075 &self,
1076 user_key: &str,
1077 ) -> (Option<String>, Option<std::path::PathBuf>) {
1078 (self.config_toml.clone(), self.get_user_home_dir(user_key))
1079 }
1080
1081 fn apply_user_isolation(&self, session: &mut Session, user_key: &str) {
1090 if std::env::var("TRUSTEE_CLASSIC_HOME").as_deref() == Ok("1") {
1093 if let Some(home) = dirs::home_dir() {
1094 session.home_dir = Some(home.join(".trustee"));
1095 }
1096 return;
1097 }
1098 let user_key = effective_user_key(user_key);
1099 let user_hash = trustee_core::user_hash(&user_key);
1100
1101 let user_home = if let Some(home) = dirs::home_dir() {
1103 let user_home = home.join(".trustee").join("users").join(&user_hash);
1104 session.home_dir = Some(user_home.clone());
1105 Some(user_home)
1106 } else {
1107 None
1108 };
1109
1110 if let Some(ref user_home) = user_home {
1114 if materialized_user_missing_env(user_home) {
1115 tracing::warn!(
1116 "user namespace {} is materialized but has NO per-user .env — \
1117 ${{…}} references will fall through to process env \
1118 (global ~/.trustee/.env) and execute under the GLOBAL principal",
1119 &user_hash[..8.min(user_hash.len())]
1120 );
1121 }
1122 }
1123
1124 session.project_id = Some(format!("web{}", &user_hash[..16]));
1125
1126 let shared_secrets = session.secrets.clone().unwrap_or_default();
1133 let mut merged_secrets = shared_secrets.clone();
1134
1135 if let Some(ref user_home) = user_home {
1136 if let Ok(merged) = self.load_user_secrets(user_home, &merged_secrets) {
1137 merged_secrets = merged;
1138 }
1139 }
1140
1141 if let Some(ref user_home) = user_home {
1143 if let Some(merged) = self.merge_user_config(user_home, session.config_toml.as_deref())
1144 {
1145 session.config_toml = Some(merged);
1146 tracing::debug!("Merged per-user config into session");
1147 }
1148 }
1149
1150 if let Some(ref mut config_toml) = session.config_toml {
1152 substitute_env_vars(
1153 config_toml,
1154 &merged_secrets,
1155 &format!("user {}", &user_hash[..8.min(user_hash.len())]),
1156 );
1157 }
1158
1159 session.secrets = Some(shared_secrets);
1161 }
1162
1163 fn load_user_secrets(
1166 &self,
1167 user_home: &std::path::Path,
1168 base: &std::collections::HashMap<String, String>,
1169 ) -> std::io::Result<std::collections::HashMap<String, String>> {
1170 let user_env_path = user_home.join(".env");
1171 if !user_env_path.exists() {
1172 return Ok(base.clone());
1173 }
1174 let content = std::fs::read_to_string(&user_env_path)?;
1175 let mut merged = base.clone();
1176 for line in content.lines() {
1177 let line = line.trim();
1178 if line.is_empty() || line.starts_with('#') {
1179 continue;
1180 }
1181 if let Some((key, value)) = line.split_once('=') {
1182 let key = key.trim().to_string();
1183 let value = value
1184 .trim()
1185 .trim_matches('"')
1186 .trim_matches('\'')
1187 .to_string();
1188 merged.insert(key, value);
1189 }
1190 }
1191 tracing::debug!("Loaded per-user secrets from {}", user_env_path.display());
1192 Ok(merged)
1193 }
1194
1195 fn merge_user_config(
1210 &self,
1211 user_home: &std::path::Path,
1212 shared_config: Option<&str>,
1213 ) -> Option<String> {
1214 let user_config_path = user_home.join("config").join("trustee.toml");
1215 if !user_config_path.exists() {
1216 return None;
1217 }
1218 let user_config_toml = std::fs::read_to_string(&user_config_path).ok()?;
1219 let shared = shared_config.unwrap_or("").parse::<toml::Value>().ok()?;
1220 let overlay = user_config_toml.parse::<toml::Value>().ok()?;
1221
1222 let allowed = |section: &str| {
1223 section == "mcp"
1224 || section == "thq"
1228 || section == "lifecycle"
1233 || (self.allow_llm_overlay && section == "llm")
1234 };
1235 let dir_name = user_home
1238 .file_name()
1239 .and_then(|n| n.to_str())
1240 .unwrap_or("<unknown>");
1241 let masked_user = dir_name.get(..8).unwrap_or(dir_name);
1242
1243 let mut filtered_overlay = toml::map::Map::new();
1244 if let Some(table) = overlay.as_table() {
1245 for (section, value) in table {
1246 if section == "lifecycle" {
1247 let mut v = value.clone();
1248 if let Some(t) = v.as_table_mut() {
1249 if t.remove("enabled").is_some() {
1250 tracing::info!(
1251 "user config overlay: [lifecycle].enabled is not user-settable — stripped for user {}",
1252 masked_user
1253 );
1254 }
1255 }
1256 filtered_overlay.insert(section.clone(), v);
1257 } else if allowed(section) {
1258 filtered_overlay.insert(section.clone(), value.clone());
1259 } else {
1260 tracing::warn!(
1261 "user config overlay: dropping non-allowlisted section [{}] for user {}",
1262 section,
1263 masked_user
1264 );
1265 }
1266 }
1267 }
1268
1269 if filtered_overlay.is_empty() {
1270 return None;
1272 }
1273 let overlay = toml::Value::Table(filtered_overlay);
1274
1275 let mut shared = shared;
1276 deep_merge_toml(&mut shared, &overlay);
1277 let merged = toml::to_string(&shared).ok()?;
1278 tracing::debug!("Merged per-user config from {}", user_config_path.display());
1279 Some(merged)
1280 }
1281
1282 pub fn resolve_user_config(&self, user_key: &str) -> Option<String> {
1291 let config_toml = self.config_toml.clone()?;
1292
1293 let user_home = self.get_user_home_dir(user_key)?;
1295
1296 let mut merged_secrets = self.secrets.clone().unwrap_or_default();
1298 if let Ok(merged) = self.load_user_secrets(&user_home, &merged_secrets) {
1299 merged_secrets = merged;
1300 }
1301
1302 let mut resolved = config_toml;
1304 if let Some(merged) = self.merge_user_config(&user_home, Some(&resolved)) {
1305 resolved = merged;
1306 }
1307
1308 substitute_env_vars(
1310 &mut resolved,
1311 &merged_secrets,
1312 &format!(
1313 "resolve_user_config user {}",
1314 &trustee_core::user_hash(user_key)[..8]
1315 ),
1316 );
1317
1318 Some(resolved)
1319 }
1320
1321 pub async fn get_or_build_mcp_loader(
1337 &self,
1338 user_key: &str,
1339 token_store: &Arc<pep::MemoryTokenStore>,
1340 ) -> Result<Option<std::sync::Arc<abk::agent::McpToolLoader>>, String> {
1341 let user_key = effective_user_key(user_key);
1342 let user_hash = trustee_core::user_hash(&user_key);
1343
1344 let resolved = self.resolve_user_config(&user_key);
1346 let fingerprint = fingerprint_mcp_section(resolved.as_deref());
1347
1348 if let Some(entry) = self.mcp_loaders.get(&user_hash) {
1350 match loader_freshness(
1351 entry.fingerprint,
1352 entry.built_at,
1353 entry.degraded.as_deref(),
1354 entry.failed_at,
1355 fingerprint,
1356 chrono::Utc::now(),
1357 ) {
1358 LoaderFreshness::Fresh => return Ok(entry.loader.clone()),
1359 LoaderFreshness::ConfigChanged => {
1360 }
1362 LoaderFreshness::AgedOut => {
1363 tracing::info!(
1366 "MCP toolset for user {} is {}s old (max {}s) — rebuilding \
1367 to re-list the served surface (phantom-tool guard)",
1368 &user_hash[..8.min(user_hash.len())],
1369 (chrono::Utc::now() - entry.built_at).num_seconds(),
1370 MCP_TOOLSET_MAX_AGE.as_secs()
1371 );
1372 }
1373 LoaderFreshness::Backoff(remaining) => {
1374 let err = entry.degraded.clone().unwrap_or_else(|| {
1375 "previous MCP loader build failed; retry after backoff".to_string()
1376 });
1377 let _ = remaining;
1378 return Err(err);
1379 }
1380 }
1381 }
1382
1383 let lock = self
1385 .mcp_build_locks
1386 .entry(user_hash.clone())
1387 .or_insert_with(|| Arc::new(tokio::sync::Mutex::new(())))
1388 .clone();
1389 let _guard = lock.lock().await;
1390
1391 if let Some(entry) = self.mcp_loaders.get(&user_hash) {
1393 if loader_freshness(
1394 entry.fingerprint,
1395 entry.built_at,
1396 entry.degraded.as_deref(),
1397 entry.failed_at,
1398 fingerprint,
1399 chrono::Utc::now(),
1400 ) == LoaderFreshness::Fresh
1401 {
1402 return Ok(entry.loader.clone());
1403 }
1404 }
1405
1406 match self
1407 .build_mcp_loader(&user_hash, resolved.as_deref(), fingerprint, token_store)
1408 .await
1409 {
1410 Ok(entry) => {
1411 self.mcp_loaders.insert(user_hash.clone(), entry);
1412 Ok(self.mcp_loaders.get(&user_hash).unwrap().loader.clone())
1413 }
1414 Err(err) => {
1415 tracing::warn!(
1416 "MCP loader build FAILED for user {}; dispatch fails loud, retry after {:?}",
1417 &user_hash[..8.min(user_hash.len())],
1418 MCP_BUILD_RETRY_BACKOFF
1419 );
1420 self.mcp_loaders.insert(
1421 user_hash,
1422 McpLoaderEntry {
1423 loader: None,
1424 fingerprint,
1425 built_at: chrono::Utc::now(),
1426 degraded: Some(err.clone()),
1427 failed_at: Some(chrono::Utc::now()),
1428 },
1429 );
1430 Err(err)
1431 }
1432 }
1433 }
1434
1435 async fn build_mcp_loader(
1438 &self,
1439 user_hash: &str,
1440 resolved: Option<&str>,
1441 fingerprint: u64,
1442 token_store: &Arc<pep::MemoryTokenStore>,
1443 ) -> Result<McpLoaderEntry, String> {
1444 let mcp_config: Option<abk::config::McpConfig> = match resolved {
1445 Some(toml_str) => {
1446 let value = toml_str
1447 .parse::<toml::Value>()
1448 .map_err(|e| format!("config parse failed: {}", e))?;
1449 match value.get("mcp") {
1450 Some(section) => {
1451 let mut leftovers: Vec<String> = Vec::new();
1458 collect_unresolved_placeholders(section, &mut leftovers);
1459 if !leftovers.is_empty() {
1460 return Err(format!(
1461 "unresolved {} placeholder(s) in [mcp]: {} — supply the \
1462 exact-case key in the profile secrets",
1463 leftovers.len(),
1464 leftovers.join(", ")
1465 ));
1466 }
1467 use serde::Deserialize as _;
1468 Some(
1469 abk::config::McpConfig::deserialize(section.clone())
1470 .map_err(|e| format!("invalid [mcp] config: {}", e))?,
1471 )
1472 }
1473 None => None,
1474 }
1475 }
1476 None => None,
1477 };
1478
1479 let loader = match mcp_config {
1480 Some(cfg) if cfg.enabled => {
1481 let built = abk::agent::McpToolLoader::with_token_store(
1482 &cfg,
1483 Some(token_store.clone() as std::sync::Arc<dyn pep::token_store::TokenStore>),
1484 )
1485 .await
1486 .map_err(|e| format!("MCP loader build failed: {}", e))?;
1487
1488 let servers: Vec<String> = built
1492 .server_statuses
1493 .iter()
1494 .map(|s| {
1495 if s.connected {
1496 format!("{}(up,{}tools)", s.name, s.tool_count)
1497 } else {
1498 format!("{}(DOWN)", s.name)
1499 }
1500 })
1501 .collect();
1502 tracing::info!(
1503 "MCP loader built for user {}: servers=[{}] total_tools={}",
1504 &user_hash[..8.min(user_hash.len())],
1505 servers.join(", "),
1506 built.tool_count
1507 );
1508 Some(std::sync::Arc::new(built))
1509 }
1510 _ => None,
1511 };
1512
1513 Ok(McpLoaderEntry {
1514 loader,
1515 fingerprint,
1516 built_at: chrono::Utc::now(),
1517 degraded: None,
1518 failed_at: None,
1519 })
1520 }
1521
1522 fn spawn_user_drain_task(
1524 &self,
1525 session_id: String,
1526 session: Arc<Mutex<Session>>,
1527 ws_tx: broadcast::Sender<String>,
1528 mut workflow_rx: mpsc::UnboundedReceiver<TuiMessage>,
1529 ) -> tokio::task::JoinHandle<()> {
1530 let mut last_broadcast_state: Option<String> = None;
1536 tokio::spawn(async move {
1537 while let Some(msg) = workflow_rx.recv().await {
1538 {
1539 let mut session = session.lock().await;
1540 session.handle_workflow_message(msg.clone());
1541
1542 let state_str = match session.workflow_state {
1543 trustee_core::types::WorkflowState::Idle => "Idle",
1544 trustee_core::types::WorkflowState::Running => "Running",
1545 trustee_core::types::WorkflowState::Cancelling => "Cancelling",
1546 };
1547 if last_broadcast_state.as_deref() != Some(state_str) {
1548 last_broadcast_state = Some(state_str.to_string());
1549 let state_msg = serde_json::json!({
1550 "type": "StateChanged",
1551 "state": state_str
1552 });
1553 let _ = ws_tx.send(state_msg.to_string());
1554 }
1555 }
1556
1557 let json = serde_json::to_string(&SerializableMessage(&msg)).unwrap_or_default();
1558 let _ = ws_tx.send(json);
1559 }
1560 tracing::debug!("Drain task ended for session: {}", session_id);
1561 })
1562 }
1563
1564 pub fn spawn_drain_task(self, mut workflow_rx: mpsc::UnboundedReceiver<TuiMessage>) {
1567 let default_user = self
1569 .sessions
1570 .get("default")
1571 .expect("default user must exist");
1572 let first_entry = default_user
1573 .sessions
1574 .iter()
1575 .next()
1576 .expect("default user must have at least one session");
1577 let session = first_entry.session.clone();
1578 let ws_tx = first_entry.ws_tx.clone();
1579 let session_id = first_entry.key().clone();
1580 drop(first_entry);
1581 drop(default_user);
1582
1583 let mut last_broadcast_state = Some("Running".to_string());
1587 let session_id_for_handle = session_id.clone();
1588 let handle = tokio::spawn(async move {
1589 while let Some(msg) = workflow_rx.recv().await {
1590 {
1591 let mut session = session.lock().await;
1592 session.handle_workflow_message(msg.clone());
1593
1594 let state_str = match session.workflow_state {
1595 trustee_core::types::WorkflowState::Idle => "Idle",
1596 trustee_core::types::WorkflowState::Running => "Running",
1597 trustee_core::types::WorkflowState::Cancelling => "Cancelling",
1598 };
1599 if last_broadcast_state.as_deref() != Some(state_str) {
1600 last_broadcast_state = Some(state_str.to_string());
1601 let state_msg = serde_json::json!({
1602 "type": "StateChanged",
1603 "state": state_str
1604 });
1605 let _ = ws_tx.send(state_msg.to_string());
1606 }
1607 }
1608
1609 let json = serde_json::to_string(&SerializableMessage(&msg)).unwrap_or_default();
1610 let _ = ws_tx.send(json);
1611 }
1612 tracing::debug!("Drain task ended for session: {}", session_id);
1613 });
1614 if let Some(default_user) = self.sessions.get("default") {
1618 if let Some(mut e) = default_user.sessions.get_mut(&session_id_for_handle) {
1619 e.drain_abort = Some(handle.abort_handle());
1620 }
1621 }
1622 }
1623
1624 pub async fn resolve_user_key(&self, headers: &axum::http::HeaderMap) -> String {
1626 let Some(ref auth) = self.auth else {
1627 return "default".to_string();
1628 };
1629
1630 if let Some(token) = headers
1632 .get(axum::http::header::AUTHORIZATION)
1633 .and_then(|v| v.to_str().ok())
1634 .and_then(|v| v.strip_prefix("Bearer "))
1635 .map(|s| s.to_string())
1636 {
1637 if token.starts_with("dev:") {
1638 let parts: Vec<&str> = token.splitn(4, ':').collect();
1639 if parts.len() >= 4 {
1640 return format!("dev:{}", parts[1]);
1641 }
1642 }
1643 if let Ok(claims) = auth.validate_token(&token).await {
1644 return claims.sub;
1645 }
1646 }
1647
1648 let cookie_session_id = headers
1650 .get(axum::http::header::COOKIE)
1651 .and_then(|v| v.to_str().ok())
1652 .and_then(|cookies| {
1653 cookies.split(';').map(|c| c.trim()).find_map(|c| {
1654 c.strip_prefix(&format!("{}=", auth.config.cookie_name))
1655 .map(|s| s.to_string())
1656 })
1657 });
1658
1659 if let Some(session_id) = cookie_session_id {
1660 if session_id.starts_with("dev:") {
1661 let parts: Vec<&str> = session_id.splitn(4, ':').collect();
1662 if parts.len() >= 4 {
1663 return format!("dev:{}", parts[1]);
1664 }
1665 }
1666
1667 if let Ok(access_token) = auth.session_manager.get_token(&session_id).await {
1668 if let Ok(claims) = auth.validate_token(&access_token).await {
1669 return claims.sub;
1670 }
1671 }
1672 }
1673
1674 "default".to_string()
1675 }
1676}
1677
1678struct SerializableMessage<'a>(&'a TuiMessage);
1684
1685impl<'a> serde::Serialize for SerializableMessage<'a> {
1686 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1687 where
1688 S: serde::Serializer,
1689 {
1690 use serde::ser::SerializeStruct;
1691
1692 match self.0 {
1693 TuiMessage::OutputLine(line) => {
1694 let mut s = serializer.serialize_struct("msg", 2)?;
1695 s.serialize_field("type", "OutputLine")?;
1696 s.serialize_field("line", line)?;
1697 s.end()
1698 }
1699 TuiMessage::StreamDelta(delta) => {
1700 let mut s = serializer.serialize_struct("msg", 2)?;
1701 s.serialize_field("type", "StreamDelta")?;
1702 s.serialize_field("delta", delta)?;
1703 s.end()
1704 }
1705 TuiMessage::ReasoningDelta(delta) => {
1706 let mut s = serializer.serialize_struct("msg", 2)?;
1707 s.serialize_field("type", "ReasoningDelta")?;
1708 s.serialize_field("delta", delta)?;
1709 s.end()
1710 }
1711 TuiMessage::WorkflowCompleted => {
1712 let mut s = serializer.serialize_struct("msg", 2)?;
1713 s.serialize_field("type", "WorkflowCompleted")?;
1714 s.serialize_field("state", "Idle")?;
1715 s.end()
1716 }
1717 TuiMessage::WorkflowError(err) => {
1718 let mut s = serializer.serialize_struct("msg", 2)?;
1719 s.serialize_field("type", "WorkflowError")?;
1720 s.serialize_field("error", err)?;
1721 s.end()
1722 }
1723 TuiMessage::ResumeInfo(info) => match info {
1724 Some(ri) => {
1725 let mut s = serializer.serialize_struct("msg", 5)?;
1726 s.serialize_field("type", "ResumeInfo")?;
1727 s.serialize_field("state", "Idle")?;
1728 s.serialize_field("session_id", &ri.session_id)?;
1729 s.serialize_field("checkpoint_id", &ri.checkpoint_id)?;
1730 s.serialize_field("iteration", &ri.iteration)?;
1731 s.end()
1732 }
1733 None => {
1734 let mut s = serializer.serialize_struct("msg", 2)?;
1735 s.serialize_field("type", "ResumeInfo")?;
1736 s.serialize_field("state", "Idle")?;
1737 s.end()
1738 }
1739 },
1740 TuiMessage::TodoUpdate(content) => {
1741 let mut s = serializer.serialize_struct("msg", 2)?;
1742 s.serialize_field("type", "TodoUpdate")?;
1743 s.serialize_field("content", content)?;
1744 s.end()
1745 }
1746 TuiMessage::WorkflowCancelled => {
1747 let mut s = serializer.serialize_struct("msg", 2)?;
1748 s.serialize_field("type", "WorkflowCancelled")?;
1749 s.serialize_field("state", "Idle")?;
1750 s.end()
1751 }
1752 TuiMessage::HandoffReady(briefing) => {
1753 let mut s = serializer.serialize_struct("msg", 3)?;
1754 s.serialize_field("type", "HandoffReady")?;
1755 s.serialize_field("state", "Idle")?;
1756 s.serialize_field("briefing", briefing)?;
1757 s.end()
1758 }
1759 TuiMessage::SessionRotated { old, new } => {
1760 let mut s = serializer.serialize_struct("msg", 3)?;
1761 s.serialize_field("type", "SessionRotated")?;
1762 s.serialize_field("old", old)?;
1763 s.serialize_field("new", new)?;
1764 s.end()
1765 }
1766 TuiMessage::HandoffFailed => {
1767 let mut s = serializer.serialize_struct("msg", 2)?;
1768 s.serialize_field("type", "HandoffFailed")?;
1769 s.serialize_field("state", "Idle")?;
1770 s.end()
1771 }
1772 TuiMessage::ToolPending { tool_name, hint } => {
1773 let mut s = serializer.serialize_struct("msg", 3)?;
1774 s.serialize_field("type", "ToolPending")?;
1775 s.serialize_field("tool_name", tool_name)?;
1776 s.serialize_field("hint", hint)?;
1777 s.end()
1778 }
1779 TuiMessage::ToolDone {
1780 tool_name,
1781 success,
1782 hint,
1783 } => {
1784 let mut s = serializer.serialize_struct("msg", 4)?;
1785 s.serialize_field("type", "ToolDone")?;
1786 s.serialize_field("tool_name", tool_name)?;
1787 s.serialize_field("success", success)?;
1788 s.serialize_field("hint", hint)?;
1789 s.end()
1790 }
1791 TuiMessage::ContextTokensUpdated(count) => {
1792 let mut s = serializer.serialize_struct("msg", 2)?;
1793 s.serialize_field("type", "ContextTokensUpdated")?;
1794 s.serialize_field("count", count)?;
1795 s.end()
1796 }
1797 TuiMessage::McpServerStatus {
1798 name,
1799 connected,
1800 tool_count,
1801 error,
1802 } => {
1803 let mut s = serializer.serialize_struct("msg", 5)?;
1804 s.serialize_field("type", "McpServerStatus")?;
1805 s.serialize_field("name", name)?;
1806 s.serialize_field("connected", connected)?;
1807 s.serialize_field("tool_count", tool_count)?;
1808 s.serialize_field("error", error)?;
1809 s.end()
1810 }
1811 TuiMessage::SessionTitleUpdated(title) => {
1812 let mut s = serializer.serialize_struct("msg", 2)?;
1813 s.serialize_field("type", "SessionTitleUpdated")?;
1814 s.serialize_field("title", title)?;
1815 s.end()
1816 }
1817 }
1818 }
1819}
1820
1821fn deep_merge_toml(base: &mut toml::Value, overlay: &toml::Value) {
1832 match (base, overlay) {
1833 (toml::Value::Table(base_table), toml::Value::Table(overlay_table)) => {
1834 for (key, overlay_val) in overlay_table {
1835 match base_table.get_mut(key) {
1836 Some(base_val) => {
1837 deep_merge_toml(base_val, overlay_val);
1839 }
1840 None => {
1841 base_table.insert(key.clone(), overlay_val.clone());
1843 }
1844 }
1845 }
1846 }
1847 (base, overlay) => {
1849 *base = overlay.clone();
1850 }
1851 }
1852}
1853
1854fn collect_unresolved_placeholders(value: &toml::Value, out: &mut Vec<String>) {
1861 match value {
1862 toml::Value::String(s) => {
1863 if let Some(start) = s.find("${") {
1864 if let Some(end_rel) = s[start + 2..].find('}') {
1865 let name = &s[start + 2..start + 2 + end_rel];
1866 let rendered = format!("${{{name}}}");
1867 if !out.contains(&rendered) {
1868 out.push(rendered);
1869 }
1870 }
1871 }
1872 }
1873 toml::Value::Table(t) => {
1874 for v in t.values() {
1875 collect_unresolved_placeholders(v, out);
1876 }
1877 }
1878 toml::Value::Array(a) => {
1879 for v in a {
1880 collect_unresolved_placeholders(v, out);
1881 }
1882 }
1883 _ => {}
1884 }
1885}
1886
1887#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1889pub(crate) enum SecretSource {
1890 SecretsMap,
1893 ProcessEnv,
1899 Unresolved,
1901}
1902
1903#[derive(Debug, Clone, PartialEq, Eq)]
1905pub(crate) struct EnvVarResolution {
1906 pub name: String,
1907 pub source: SecretSource,
1908}
1909
1910fn substitute_env_vars(
1911 s: &mut String,
1912 secrets: &std::collections::HashMap<String, String>,
1913 ctx: &str,
1914) -> Vec<EnvVarResolution> {
1915 let mut result = String::with_capacity(s.len());
1917 let bytes = s.as_bytes();
1918 let mut i = 0;
1919 let mut report: Vec<EnvVarResolution> = Vec::new();
1922
1923 while i < bytes.len() {
1924 if i + 1 < bytes.len() && bytes[i] == b'$' && bytes[i + 1] == b'{' {
1925 if let Some(end) = s[i + 2..].find('}') {
1927 let var_name = &s[i + 2..i + 2 + end];
1928 let (replacement, source) = if let Some(value) = secrets.get(var_name) {
1930 (value.clone(), SecretSource::SecretsMap)
1931 } else if let Ok(value) = std::env::var(var_name) {
1932 (value, SecretSource::ProcessEnv)
1933 } else {
1934 (s[i..i + 2 + end + 1].to_string(), SecretSource::Unresolved)
1939 };
1940 if !report.iter().any(|r| r.name == var_name) {
1941 report.push(EnvVarResolution {
1942 name: var_name.to_string(),
1943 source,
1944 });
1945 }
1946 result.push_str(&replacement);
1947 i = i + 2 + end + 1;
1948 } else {
1949 result.push('$');
1951 i += 1;
1952 }
1953 } else {
1954 result.push(bytes[i] as char);
1955 i += 1;
1956 }
1957 }
1958
1959 for r in &report {
1964 match r.source {
1965 SecretSource::ProcessEnv => tracing::error!(
1966 "CREDENTIAL PROVENANCE [{}]: ${{{}}} resolved from PROCESS ENV \
1967 (global ~/.trustee/.env at boot) — no per-user/profile secret \
1968 answered; calls using it execute under the GLOBAL principal. \
1969 Supply the exact-case key in the per-user .env / profile \
1970 secrets to restore attribution.",
1971 ctx,
1972 r.name
1973 ),
1974 SecretSource::Unresolved => {
1975 }
1977 SecretSource::SecretsMap => tracing::debug!(
1978 "CREDENTIAL PROVENANCE [{}]: ${{{}}} resolved from profile/user secrets",
1979 ctx,
1980 r.name
1981 ),
1982 }
1983 }
1984 let unresolved: Vec<&str> = report
1985 .iter()
1986 .filter(|r| r.source == SecretSource::Unresolved)
1987 .map(|r| r.name.as_str())
1988 .collect();
1989 if !unresolved.is_empty() {
1990 tracing::warn!(
1991 "ENV SUBSTITUTION LEFT {} UNRESOLVED [{}]: {} — the literal ${{…}} remains in the \
1992 effective config; supply the key in the profile secrets (exact-case KEY=VALUE) \
1993 or the environment",
1994 unresolved.len(),
1995 ctx,
1996 unresolved
1997 .iter()
1998 .map(|v| format!("${{{v}}}"))
1999 .collect::<Vec<_>>()
2000 .join(", ")
2001 );
2002 }
2003
2004 *s = result;
2005 report
2006}
2007
2008pub(crate) fn materialized_user_missing_env(user_home: &std::path::Path) -> bool {
2013 user_home.is_dir() && !user_home.join(".env").exists()
2014}
2015
2016fn fingerprint_mcp_section(resolved: Option<&str>) -> u64 {
2026 use sha2::{Digest, Sha256};
2027 let section = resolved
2028 .and_then(|s| s.parse::<toml::Value>().ok())
2029 .and_then(|v| v.get("mcp").cloned());
2030 let bytes = match section {
2031 Some(v) => v.to_string().into_bytes(),
2032 None => b"<no-mcp>".to_vec(),
2033 };
2034 let digest = Sha256::digest(&bytes);
2035 u64::from_be_bytes(digest[..8].try_into().expect("sha256 digest >= 8 bytes"))
2036}
2037
2038#[cfg(test)]
2039mod tests {
2040 use super::*;
2041
2042 fn test_state() -> ServerState {
2044 let (session, _rx) = Session::new();
2045 let (ws_tx, _ws_rx) = tokio::sync::broadcast::channel::<String>(16);
2046 ServerState::new(session, ws_tx, None)
2047 }
2048
2049 #[tokio::test]
2050 async fn dispatch_scope_pins_user_key_resolution() {
2051 let state = test_state();
2055 let caller = "some-human-sub";
2056 let plain_home = state.get_user_home_dir(caller).unwrap();
2057 let pinned_key = "prof-1234";
2058 let pinned_home = in_dispatch_scope(pinned_key, async {
2059 state.get_user_home_dir(caller).unwrap()
2060 })
2061 .await;
2062 let users_root = dirs::home_dir().unwrap().join(".trustee").join("users");
2063 assert_eq!(plain_home, users_root.join(trustee_core::user_hash(caller)));
2064 assert_eq!(
2065 pinned_home,
2066 users_root.join(trustee_core::user_hash(pinned_key)),
2067 "dispatch scope must pin resolution to the binding key"
2068 );
2069 assert_ne!(plain_home, pinned_home);
2070 }
2071
2072 fn temp_user_home(tag: &str) -> std::path::PathBuf {
2074 static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
2075 let n = COUNTER.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
2076 let dir = std::env::temp_dir().join(format!(
2077 "trustee-state-test-{}-{}-{}",
2078 tag,
2079 std::process::id(),
2080 n
2081 ));
2082 std::fs::create_dir_all(dir.join("config")).expect("create temp user home");
2083 dir
2084 }
2085
2086 fn parse(toml_str: &str) -> toml::Value {
2087 toml_str.parse::<toml::Value>().expect("valid test TOML")
2088 }
2089
2090 #[test]
2093 fn overlay_allowlist_drops_non_allowlisted_sections() {
2094 let state = test_state();
2095 let home = temp_user_home("allowlist");
2096 std::fs::write(
2097 home.join("config").join("trustee.toml"),
2098 "[server]\nport = 1\n\n[auth]\nmode = \"kanidm\"\n\n[mcp]\nmode = \"user\"\n",
2099 )
2100 .expect("write overlay");
2101
2102 let shared = "[server]\nport = 8080\n\n[mcp]\nmode = \"shared\"\n";
2103 let merged = state
2104 .merge_user_config(&home, Some(shared))
2105 .expect("overlay has allowlisted content");
2106
2107 let merged_val = parse(&merged);
2108 let expected = parse("[server]\nport = 8080\n\n[mcp]\nmode = \"user\"\n");
2109 assert_eq!(
2110 merged_val, expected,
2111 "merged config must be shared + [mcp] overlay only"
2112 );
2113 assert!(
2114 merged_val.get("auth").is_none(),
2115 "overlay [auth] must be dropped"
2116 );
2117 }
2118
2119 #[test]
2121 fn no_overlay_file_returns_none() {
2122 let state = test_state();
2123 let home = temp_user_home("empty");
2124 assert!(state
2125 .merge_user_config(&home, Some("[server]\nport = 8080\n"))
2126 .is_none());
2127 }
2128
2129 #[test]
2131 fn overlay_with_no_allowlisted_sections_is_noop() {
2132 let state = test_state();
2133 let home = temp_user_home("all-dropped");
2134 std::fs::write(
2135 home.join("config").join("trustee.toml"),
2136 "[server]\nport = 1\n\n[storage]\npath = \"/tmp/x\"\n",
2137 )
2138 .expect("write overlay");
2139 assert!(state
2140 .merge_user_config(&home, Some("[server]\nport = 8080\n"))
2141 .is_none());
2142 }
2143
2144 #[test]
2147 fn llm_overlay_dropped_by_default_and_kept_when_enabled() {
2148 let shared = "[llm]\nprovider = \"openai\"\n\n[mcp]\nmode = \"shared\"\n";
2149 let overlay = "[llm]\nprovider = \"anthropic\"\n";
2150
2151 let state = test_state();
2153 assert!(!state.allow_llm_overlay);
2154 let home = temp_user_home("llm-off");
2155 std::fs::write(home.join("config").join("trustee.toml"), overlay).expect("write overlay");
2156 assert!(state.merge_user_config(&home, Some(shared)).is_none());
2157
2158 let state = test_state().with_allow_llm_overlay(true);
2160 assert!(state.allow_llm_overlay);
2161 let home = temp_user_home("llm-on");
2162 std::fs::write(home.join("config").join("trustee.toml"), overlay).expect("write overlay");
2163 let merged = state
2164 .merge_user_config(&home, Some(shared))
2165 .expect("[llm] overlay applies when opted in");
2166 let merged_val = parse(&merged);
2167 assert_eq!(merged_val["llm"]["provider"].as_str(), Some("anthropic"));
2168 assert_eq!(merged_val["mcp"]["mode"].as_str(), Some("shared"));
2169 }
2170
2171 #[test]
2175 fn user_home_dir_uses_consolidated_hash() {
2176 let state = test_state();
2177 if let Some(home) = state.get_user_home_dir("farzan@example.com") {
2178 assert_eq!(
2179 home.file_name().and_then(|n| n.to_str()),
2180 Some(trustee_core::user_hash("farzan@example.com")).as_deref()
2181 );
2182 let users_root = dirs::home_dir().unwrap().join(".trustee").join("users");
2183 assert_eq!(home.parent(), Some(&users_root).map(|p| p.as_path()));
2184 }
2185 }
2187
2188 #[test]
2191 fn lifecycle_overlay_survives_allowlist_enabled_stripped() {
2192 let state = test_state();
2193 let home = temp_user_home("lifecycle-persona");
2194 std::fs::write(
2195 home.join("config").join("trustee.toml"),
2196 "[lifecycle]\nsystem_template = \"You are Saman.\"\nenabled = true\n",
2197 )
2198 .expect("write overlay");
2199
2200 let merged = state
2201 .merge_user_config(
2202 &home,
2203 Some("[lifecycle]\nsystem_template = \"shared default\"\n"),
2204 )
2205 .expect("lifecycle overlay is allowlisted");
2206
2207 let v = merged.parse::<toml::Value>().expect("valid TOML");
2208 assert_eq!(
2209 v["lifecycle"]["system_template"].as_str(),
2210 Some("You are Saman."),
2211 "agent persona wins over shared default"
2212 );
2213 assert_eq!(
2214 v["lifecycle"].get("enabled"),
2215 None,
2216 "WASM extension switch is not user-settable"
2217 );
2218 }
2219
2220 #[tokio::test]
2225 async fn agent_principals_get_isolated_session_buckets() {
2226 let state = test_state();
2227 let key_a = "agent-farzan";
2228 let key_b = "agent-paydar";
2229
2230 let sid_a = state
2231 .create_session(key_a, None, None)
2232 .await
2233 .expect("create session");
2234 let _sid_b = state
2235 .create_session(key_b, None, None)
2236 .await
2237 .expect("create session");
2238
2239 assert!(
2241 state.get_session_by_any_id(key_a, &sid_a).await.is_some(),
2242 "owner bucket resolves its own session"
2243 );
2244 assert!(
2245 state.get_session_by_any_id(key_b, &sid_a).await.is_none(),
2246 "cross-agent session access must be 404/None"
2247 );
2248
2249 if let Some(home) = state.get_user_home_dir(key_a) {
2251 assert_eq!(
2252 home.file_name().and_then(|n| n.to_str()),
2253 Some(trustee_core::user_hash(key_a)).as_deref()
2254 );
2255 }
2256 }
2257}
2258
2259#[cfg(test)]
2264mod mcp_loader_cache_tests {
2265 use super::*;
2266
2267 fn state_with_shared(shared: &str) -> ServerState {
2268 let (session, _rx) = Session::new();
2269 let (ws_tx, _ws_rx) = tokio::sync::broadcast::channel::<String>(16);
2270 let mut state = ServerState::new(session, ws_tx, None);
2271 state.config_toml = Some(shared.to_string());
2272 state
2273 }
2274
2275 struct TempUser {
2279 key: String,
2280 home: std::path::PathBuf,
2281 }
2282
2283 impl TempUser {
2284 fn new(tag: &str) -> Self {
2285 let key = format!("16c-{tag}-{}@test.invalid", std::process::id());
2286 let home = dirs::home_dir()
2287 .expect("HOME available in test env")
2288 .join(".trustee")
2289 .join("users")
2290 .join(trustee_core::user_hash(&key));
2291 std::fs::create_dir_all(home.join("config")).expect("create user home");
2292 Self { key, home }
2293 }
2294
2295 fn write_overlay(&self, toml_str: &str) {
2296 std::fs::write(self.home.join("config").join("trustee.toml"), toml_str)
2297 .expect("write overlay");
2298 }
2299 }
2300
2301 impl Drop for TempUser {
2302 fn drop(&mut self) {
2303 let _ = std::fs::remove_dir_all(&self.home);
2304 }
2305 }
2306
2307 #[tokio::test]
2308 async fn no_mcp_config_caches_disabled_marker() {
2309 let state = state_with_shared("[server]\nport = 8080\n");
2310 let user = TempUser::new("nomcp");
2311 let ts = Arc::new(pep::MemoryTokenStore::new());
2312
2313 let first = state.get_or_build_mcp_loader(&user.key, &ts).await.unwrap();
2314 assert!(first.is_none(), "no [mcp] anywhere → disabled marker");
2315 assert_eq!(state.mcp_loaders.len(), 1, "exactly one cache entry");
2316
2317 let second = state.get_or_build_mcp_loader(&user.key, &ts).await.unwrap();
2319 assert!(second.is_none());
2320 assert_eq!(state.mcp_loaders.len(), 1);
2321 }
2322
2323 #[tokio::test]
2324 async fn concurrent_cold_builds_single_flight() {
2325 let state = Arc::new(state_with_shared("[server]\nport = 8080\n"));
2326 let user = TempUser::new("singleflight");
2327 let ts = Arc::new(pep::MemoryTokenStore::new());
2328
2329 let mut handles = Vec::new();
2330 for _ in 0..5 {
2331 let state = state.clone();
2332 let key = user.key.clone();
2333 let ts = ts.clone();
2334 handles.push(tokio::spawn(async move {
2335 state.get_or_build_mcp_loader(&key, &ts).await
2336 }));
2337 }
2338 for h in handles {
2339 h.await.unwrap().expect("all five succeed");
2340 }
2341 assert_eq!(state.mcp_loaders.len(), 1, "single-flight → one entry");
2342 }
2343
2344 #[tokio::test]
2345 async fn fingerprint_change_triggers_rebuild() {
2346 let state = state_with_shared("[server]\nport = 8080\n");
2347 let user = TempUser::new("fpchange");
2348 let ts = Arc::new(pep::MemoryTokenStore::new());
2349
2350 user.write_overlay("[mcp]\nenabled = true\n\n[[mcp.servers]]\nname = \"v1\"\nurl = \"http://127.0.0.1:9/sse\"\n");
2353 let v1 = state.get_or_build_mcp_loader(&user.key, &ts).await.unwrap();
2354 assert!(v1.is_some(), "enabled [mcp] → real loader");
2355 let fp1 = state
2356 .mcp_loaders
2357 .get(&trustee_core::user_hash(&user.key))
2358 .unwrap()
2359 .fingerprint;
2360
2361 std::thread::sleep(std::time::Duration::from_millis(5));
2363 user.write_overlay("[mcp]\nenabled = true\n\n[[mcp.servers]]\nname = \"v2\"\nurl = \"http://127.0.0.1:9/other\"\n");
2364 let v2 = state.get_or_build_mcp_loader(&user.key, &ts).await.unwrap();
2365 assert!(v2.is_some());
2366 let entry = state
2367 .mcp_loaders
2368 .get(&trustee_core::user_hash(&user.key))
2369 .unwrap();
2370 assert_ne!(
2371 entry.fingerprint, fp1,
2372 "fingerprint must change with content"
2373 );
2374 assert!(entry.degraded.is_none());
2375
2376 let _still_usable = v1.as_ref().unwrap().tool_count;
2378 }
2379
2380 #[tokio::test]
2381 async fn degraded_entry_fails_loud_within_backoff_and_isolates_users() {
2382 let state = state_with_shared("[server]\nport = 8080\n");
2383 let bad = TempUser::new("degraded-bad");
2384 let good = TempUser::new("degraded-good");
2385 let ts = Arc::new(pep::MemoryTokenStore::new());
2386
2387 bad.write_overlay("[mcp]\nenabled = \"not-a-bool\"\n");
2389 let err = match state.get_or_build_mcp_loader(&bad.key, &ts).await {
2390 Ok(_) => panic!("invalid [mcp] must fail loud"),
2391 Err(e) => e,
2392 };
2393 assert!(
2394 err.contains("invalid [mcp]"),
2395 "surfaces the parse error: {err}"
2396 );
2397
2398 let entry = state
2399 .mcp_loaders
2400 .get(&trustee_core::user_hash(&bad.key))
2401 .unwrap();
2402 assert!(entry.degraded.is_some(), "poison entry recorded");
2403
2404 let err2 = match state.get_or_build_mcp_loader(&bad.key, &ts).await {
2406 Ok(_) => panic!("still within backoff"),
2407 Err(e) => e,
2408 };
2409 assert_eq!(err, err2, "same cached error");
2410
2411 let good_loader = state
2413 .get_or_build_mcp_loader(&good.key, &ts)
2414 .await
2415 .expect("other user unaffected");
2416 assert!(
2417 good_loader.is_none(),
2418 "good user has no [mcp] → disabled marker"
2419 );
2420 }
2421
2422 #[tokio::test]
2423 async fn aged_out_entry_rebuilds_without_restart() {
2424 let state = state_with_shared("[server]\nport = 8080\n");
2429 let user = TempUser::new("agedout");
2430 let ts = Arc::new(pep::MemoryTokenStore::new());
2431
2432 user.write_overlay("[mcp]\nenabled = true\n\n[[mcp.servers]]\nname = \"v1\"\nurl = \"http://127.0.0.1:9/sse\"\n");
2433 let v1 = state
2434 .get_or_build_mcp_loader(&user.key, &ts)
2435 .await
2436 .expect("initial build");
2437 let v1 = v1.expect("enabled [mcp] → loader");
2438
2439 {
2442 let mut entry = state
2443 .mcp_loaders
2444 .get_mut(&trustee_core::user_hash(&user.key))
2445 .unwrap();
2446 entry.built_at = chrono::Utc::now() - chrono::Duration::seconds(601);
2447 }
2448
2449 let v2 = state
2450 .get_or_build_mcp_loader(&user.key, &ts)
2451 .await
2452 .expect("aged-out dispatch rebuilds");
2453 let v2 = v2.expect("rebuilt loader present");
2454 assert!(
2455 !Arc::ptr_eq(&v1, &v2),
2456 "aged-out entry must NOT be reused — fresh connect re-lists the served surface"
2457 );
2458 let entry = state
2459 .mcp_loaders
2460 .get(&trustee_core::user_hash(&user.key))
2461 .unwrap();
2462 assert!(
2463 chrono::Utc::now() - entry.built_at < chrono::Duration::seconds(5),
2464 "built_at refreshed by the rebuild"
2465 );
2466
2467 let v3 = state
2469 .get_or_build_mcp_loader(&user.key, &ts)
2470 .await
2471 .expect("fresh dispatch");
2472 assert!(Arc::ptr_eq(&v2, &v3.unwrap()), "young entry hits the cache");
2473 }
2474}
2475
2476#[cfg(test)]
2477mod restore_tests {
2478 use super::*;
2479
2480 fn fresh_state() -> ServerState {
2481 let (session, _rx) = Session::new();
2482 let (ws_tx, _ws_rx) = tokio::sync::broadcast::channel::<String>(16);
2483 let mut state = ServerState::new(session, ws_tx, None);
2484 state.config_toml = Some("[agent]\nname = \"trustee\"\n".to_string());
2485 state
2486 }
2487
2488 struct TempUser {
2490 key: String,
2491 }
2492
2493 impl TempUser {
2494 fn new(tag: &str) -> Self {
2495 let key = format!("restore-{tag}-{}@test.invalid", std::process::id());
2496 let home = dirs::home_dir()
2497 .expect("HOME available in test env")
2498 .join(".trustee")
2499 .join("users")
2500 .join(trustee_core::user_hash(&key));
2501 std::fs::create_dir_all(home).expect("create user home");
2502 Self { key }
2503 }
2504 }
2505
2506 #[tokio::test]
2507 async fn restore_unknown_chain_returns_none() {
2508 let state = fresh_state();
2509 let user = TempUser::new("unknown");
2510 let out = state
2511 .get_or_restore_session_by_any_id(&user.key, "session_2099_01_01_00_00_deadbeef")
2512 .await;
2513 assert!(out.is_none(), "unknown chain must 404, not restore");
2514 }
2515
2516 #[tokio::test]
2517 async fn destroy_tombstones_chain_id() {
2518 let state = fresh_state();
2519 let user = TempUser::new("tombstone");
2520 let sid = state
2521 .create_session(&user.key, None, None)
2522 .await
2523 .expect("create session");
2524
2525 let (session, _ws) = state.get_session(&user.key, &sid).await.unwrap();
2527 {
2528 let mut s = session.lock().await;
2529 s.session_id = Some("session_2026_09_04_10_00_aaaabbbb".to_string());
2530 }
2531
2532 state
2533 .destroy_session(&user.key, &sid)
2534 .await
2535 .expect("destroy");
2536
2537 let path = state
2538 .tombstone_path(&user.key, "session_2026_09_04_10_00_aaaabbbb")
2539 .expect("tombstone path");
2540 assert!(path.exists(), "destroy must write a chain tombstone");
2541
2542 let sid2 = state
2544 .create_session(&user.key, None, None)
2545 .await
2546 .expect("create second session");
2547 state
2548 .destroy_session(&user.key, &sid2)
2549 .await
2550 .expect("destroy 2");
2551 }
2553
2554 #[tokio::test]
2555 async fn destroy_closes_the_broadcast_channel() {
2556 let state = fresh_state();
2566 let user = TempUser::new("ws-close");
2567 let sid = state
2568 .create_session(&user.key, None, None)
2569 .await
2570 .expect("create session");
2571
2572 let (_, ws_tx) = state.get_session(&user.key, &sid).await.unwrap();
2573 let mut rx = ws_tx.subscribe();
2574 drop(ws_tx); state
2577 .destroy_session(&user.key, &sid)
2578 .await
2579 .expect("destroy");
2580
2581 let outcome = rx.recv().await;
2586 assert!(
2587 matches!(
2588 outcome,
2589 Err(tokio::sync::broadcast::error::RecvError::Closed)
2590 ),
2591 "destroy must close the broadcast channel (the drain task aborted), got {outcome:?}"
2592 );
2593 }
2594
2595 #[tokio::test]
2596 async fn restore_refuses_registry_key_shapes() {
2597 let state = fresh_state();
2601 let user = TempUser::new("shapes");
2602 assert!(state.tombstone_path(&user.key, "default").is_none());
2603 let out = state
2604 .get_or_restore_session_by_any_id(&user.key, "default")
2605 .await;
2606 assert!(out.is_none());
2607 }
2608}
2609
2610#[test]
2611fn collect_unresolved_placeholders_walks_the_tree() {
2612 let section: toml::Value = toml::from_str(
2613 r#"
2614[credentials.farzan_service_account]
2615service_token = "${FARZAN_SERVICE_ACCOUNT}"
2616issuer_url = "https://ok.example"
2617
2618[[servers]]
2619name = "fame"
2620url = "https://fame.example"
2621credentials = "farzan_service_account"
2622
2623[[servers]]
2624name = "other"
2625url = "https://other.example"
2626token = "${OTHER_TOKEN}"
2627"#,
2628 )
2629 .unwrap();
2630 let mut out = Vec::new();
2631 collect_unresolved_placeholders(§ion, &mut out);
2632 out.sort();
2633 assert_eq!(
2634 out,
2635 vec![
2636 "${FARZAN_SERVICE_ACCOUNT}".to_string(),
2637 "${OTHER_TOKEN}".to_string()
2638 ],
2639 "every leftover placeholder in the [mcp] tree must be collected, deduped"
2640 );
2641 let clean: toml::Value = toml::from_str("[x]\ny = \"z\"\n").unwrap();
2643 let mut out2 = Vec::new();
2644 collect_unresolved_placeholders(&clean, &mut out2);
2645 assert!(out2.is_empty());
2646}
2647
2648#[test]
2649fn substitute_env_vars_resolves_and_keeps_leftovers_deterministically() {
2650 let mut secrets = std::collections::HashMap::new();
2651 secrets.insert("A_TOKEN".to_string(), "resolved-value".to_string());
2652 let mut s = "x = \"${A_TOKEN}\" y = \"${MISSING_TOKEN}\"".to_string();
2653 let report = substitute_env_vars(&mut s, &secrets, "test");
2654 assert!(s.contains("resolved-value"), "declared key resolves: {s}");
2655 assert!(
2656 s.contains("${MISSING_TOKEN}"),
2657 "undeclared key keeps the literal (the loader guard turns this into a loud failure): {s}"
2658 );
2659 assert_eq!(report.len(), 2, "one entry per distinct var: {report:?}");
2661 assert!(report.contains(&EnvVarResolution {
2662 name: "A_TOKEN".to_string(),
2663 source: SecretSource::SecretsMap
2664 }));
2665 assert!(report.contains(&EnvVarResolution {
2666 name: "MISSING_TOKEN".to_string(),
2667 source: SecretSource::Unresolved
2668 }));
2669}
2670
2671#[test]
2672fn substitute_env_vars_reports_process_env_shadow() {
2673 let var = format!("RAVAND_PROVENANCE_TEST_{}", std::process::id());
2678 std::env::set_var(&var, "global-env-answer");
2679
2680 let mut secrets = std::collections::HashMap::new();
2682 let mut s = format!("x = \"${{{var}}}\"");
2683 let report = substitute_env_vars(&mut s, &secrets, "test-shadow");
2684 assert!(s.contains("global-env-answer"), "process env answered: {s}");
2685 assert_eq!(
2686 report,
2687 vec![EnvVarResolution {
2688 name: var.clone(),
2689 source: SecretSource::ProcessEnv
2690 }]
2691 );
2692
2693 secrets.insert(var.clone(), "per-user-answer".to_string());
2696 let mut s2 = format!("x = \"${{{var}}}\"");
2697 let report2 = substitute_env_vars(&mut s2, &secrets, "test-wins");
2698 assert!(s2.contains("per-user-answer"), "user secrets win: {s2}");
2699 assert_eq!(
2700 report2,
2701 vec![EnvVarResolution {
2702 name: var.clone(),
2703 source: SecretSource::SecretsMap
2704 }]
2705 );
2706
2707 std::env::remove_var(&var);
2708}
2709
2710#[test]
2711fn materialized_user_missing_env_only_fires_on_dir_without_env() {
2712 let base = std::env::temp_dir().join(format!("trustee-envcheck-{}", std::process::id()));
2714 let _ = std::fs::remove_dir_all(&base);
2715
2716 assert!(!materialized_user_missing_env(&base.join("ghost")));
2718
2719 std::fs::create_dir_all(&base).unwrap();
2721 assert!(materialized_user_missing_env(&base));
2722
2723 std::fs::write(base.join(".env"), "K=V\n").unwrap();
2725 assert!(!materialized_user_missing_env(&base));
2726
2727 let _ = std::fs::remove_dir_all(&base);
2728}
2729
2730#[test]
2731fn loader_freshness_decides_all_four_states() {
2732 let now = chrono::Utc::now();
2733 let fp = 0xABCD_u64;
2734 let young = now - chrono::Duration::seconds(60);
2735 let old = now - chrono::Duration::seconds(601);
2736
2737 assert_eq!(
2739 loader_freshness(fp, young, None, None, fp, now),
2740 LoaderFreshness::Fresh
2741 );
2742 assert_eq!(
2744 loader_freshness(fp, old, None, None, 0x1234, now),
2745 LoaderFreshness::ConfigChanged
2746 );
2747 assert_eq!(
2749 loader_freshness(fp, old, None, None, fp, now),
2750 LoaderFreshness::AgedOut
2751 );
2752 let failed = now - chrono::Duration::seconds(10);
2754 match loader_freshness(fp, old, Some("boom"), Some(failed), fp, now) {
2755 LoaderFreshness::Backoff(remaining) => {
2756 assert!(remaining.as_secs() >= 15, "~20s left: {remaining:?}");
2757 }
2758 other => panic!("expected Backoff, got {other:?}"),
2759 }
2760 let failed_long = now - chrono::Duration::seconds(120);
2762 assert_eq!(
2763 loader_freshness(fp, old, Some("boom"), Some(failed_long), fp, now),
2764 LoaderFreshness::AgedOut
2765 );
2766}