lean_ctx/tools/
server_lifecycle.rs

1use std::path::Path;
2use std::sync::atomic::AtomicUsize;
3use std::sync::Arc;
4use std::time::Instant;
5use tokio::sync::RwLock;
6
7use crate::core::cache::SessionCache;
8use crate::core::session::SessionState;
9
10use super::autonomy;
11use super::server::{LeanCtxServer, SessionMode};
12use super::startup::detect_startup_context;
13
14impl Default for LeanCtxServer {
15    fn default() -> Self {
16        Self::new()
17    }
18}
19
20impl LeanCtxServer {
21    /// Creates a new server with default settings, auto-detecting the project root.
22    pub fn new() -> Self {
23        Self::new_with_project_root(None)
24    }
25
26    /// Creates a new server rooted at the given project directory.
27    pub fn new_with_project_root(project_root: Option<&str>) -> Self {
28        Self::new_with_startup(
29            project_root,
30            std::env::current_dir().ok().as_deref(),
31            SessionMode::Personal,
32            "default",
33            "default",
34        )
35    }
36
37    /// Creates a new server in Context OS shared mode for a specific workspace/channel.
38    pub fn new_shared_with_context(
39        project_root: &str,
40        workspace_id: &str,
41        channel_id: &str,
42    ) -> Self {
43        Self::new_with_startup(
44            Some(project_root),
45            std::env::current_dir().ok().as_deref(),
46            SessionMode::Shared,
47            workspace_id,
48            channel_id,
49        )
50    }
51
52    pub(crate) fn new_with_startup(
53        project_root: Option<&str>,
54        startup_cwd: Option<&Path>,
55        session_mode: SessionMode,
56        workspace_id: &str,
57        channel_id: &str,
58    ) -> Self {
59        let ttl = std::env::var("LEAN_CTX_CACHE_TTL")
60            .ok()
61            .and_then(|v| v.parse().ok())
62            .unwrap_or_else(|| {
63                let cfg = crate::core::config::Config::load();
64                crate::core::config::MemoryCleanup::effective(&cfg).idle_ttl_secs()
65            });
66
67        // Purge stale graph indices on startup to prevent serving outdated data
68        crate::core::graph_index::ProjectIndex::purge_stale_indices();
69
70        let startup = detect_startup_context(project_root, startup_cwd);
71        let (session, context_os) = match session_mode {
72            SessionMode::Personal => {
73                let mut session = if let Some(ref root) = startup.project_root {
74                    SessionState::load_latest_for_project_root(root).unwrap_or_default()
75                } else {
76                    SessionState::load_latest().unwrap_or_default()
77                };
78                if let Some(ref root) = startup.project_root {
79                    session.project_root = Some(root.clone());
80                }
81                if let Some(ref cwd) = startup.shell_cwd {
82                    session.shell_cwd = Some(cwd.clone());
83                }
84                (Arc::new(RwLock::new(session)), None)
85            }
86            SessionMode::Shared => {
87                let Some(ref root) = startup.project_root else {
88                    // Shared mode without a project root is not useful; fall back to personal.
89                    return Self::new_with_startup(
90                        project_root,
91                        startup_cwd,
92                        SessionMode::Personal,
93                        workspace_id,
94                        channel_id,
95                    );
96                };
97                let rt = crate::core::context_os::runtime();
98                let session = rt
99                    .shared_sessions
100                    .get_or_load(root, workspace_id, channel_id);
101                rt.metrics.record_session_loaded();
102                // Ensure shell_cwd is refreshed (best-effort).
103                if let Some(ref cwd) = startup.shell_cwd {
104                    if let Ok(mut s) = session.try_write() {
105                        s.shell_cwd = Some(cwd.clone());
106                    }
107                }
108                (session, Some(rt))
109            }
110        };
111
112        if let Some(ref root) = startup.project_root {
113            crate::core::index_orchestrator::ensure_all_background(root);
114        }
115
116        let cache = Arc::new(RwLock::new(SessionCache::new()));
117        let bm25_cache: Arc<std::sync::Mutex<Option<crate::core::bm25_cache::Bm25CacheEntry>>> =
118            Arc::new(std::sync::Mutex::new(None));
119
120        // Start the RAM guardian with real eviction via EvictionOrchestrator.
121        // Bridges memory_guard (RSS monitoring) → HomeostasisController (graduated actions).
122        let orchestrator = std::sync::Arc::new(
123            crate::core::eviction_orchestrator::EvictionOrchestrator::new(
124                cache.clone(),
125                bm25_cache.clone(),
126            ),
127        );
128        crate::core::memory_guard::start_guard(std::sync::Arc::new(move |level| {
129            orchestrator.on_pressure(level);
130        }));
131
132        Self {
133            cache,
134            session,
135            tool_calls: Arc::new(RwLock::new(Vec::new())),
136            call_count: Arc::new(AtomicUsize::new(0)),
137            cache_ttl_secs: ttl,
138            last_call: Arc::new(RwLock::new(Instant::now())),
139            agent_id: Arc::new(RwLock::new(None)),
140            client_name: Arc::new(RwLock::new(String::new())),
141            autonomy: Arc::new(autonomy::AutonomyState::new()),
142            loop_detector: Arc::new(RwLock::new(
143                crate::core::loop_detection::LoopDetector::with_config(
144                    &crate::core::config::Config::load().loop_detection,
145                ),
146            )),
147            workflow: Arc::new(RwLock::new(
148                crate::core::workflow::load_active().ok().flatten(),
149            )),
150            ledger: Arc::new(RwLock::new(
151                crate::core::context_ledger::ContextLedger::load(),
152            )),
153            pipeline_stats: Arc::new(RwLock::new(crate::core::pipeline::PipelineStats::new())),
154            session_mode,
155            workspace_id: if workspace_id.trim().is_empty() {
156                "default".to_string()
157            } else {
158                workspace_id.trim().to_string()
159            },
160            channel_id: if channel_id.trim().is_empty() {
161                "default".to_string()
162            } else {
163                channel_id.trim().to_string()
164            },
165            context_os,
166            context_ir: Some(std::sync::Arc::new(tokio::sync::RwLock::new(
167                crate::core::context_ir::ContextIrV1::load(),
168            ))),
169            registry: Some(std::sync::Arc::new(
170                crate::server::registry::build_registry(),
171            )),
172            rules_stale_checked: Arc::new(std::sync::atomic::AtomicBool::new(false)),
173            last_seen_event_id: Arc::new(std::sync::atomic::AtomicI64::new(0)),
174            startup_project_root: startup.project_root,
175            startup_shell_cwd: startup.shell_cwd,
176            peer: Arc::new(tokio::sync::RwLock::new(None)),
177            has_client_roots: Arc::new(std::sync::atomic::AtomicBool::new(false)),
178            roots_resolved: Arc::new(std::sync::atomic::AtomicBool::new(false)),
179            bm25_cache,
180            progress_sender: Arc::new(std::sync::Mutex::new(None)),
181        }
182    }
183
184    /// Clears the cache and saves the session if the TTL idle threshold has been exceeded.
185    pub async fn check_idle_expiry(&self) {
186        if self.cache_ttl_secs == 0 {
187            return;
188        }
189        let last = *self.last_call.read().await;
190        if last.elapsed().as_secs() >= self.cache_ttl_secs {
191            {
192                let mut session = self.session.write().await;
193                let _ = session.save();
194            }
195            let mut cache = self.cache.write().await;
196            let count = cache.clear();
197            if count > 0 {
198                tracing::info!(
199                    "Cache auto-cleared after {}s idle ({count} file(s))",
200                    self.cache_ttl_secs
201                );
202            }
203        }
204        *self.last_call.write().await = Instant::now();
205    }
206
207    /// Aggressive cleanup on connection drop: save session, consolidate knowledge, clear caches.
208    pub async fn shutdown(&self) {
209        {
210            let session = self.session.read().await;
211            let has_insights = !session.findings.is_empty() || !session.decisions.is_empty();
212            let root = session.project_root.clone();
213            drop(session);
214
215            if has_insights {
216                if let Some(ref root) = root {
217                    crate::tools::startup::auto_consolidate_knowledge(root);
218                }
219            }
220        }
221        {
222            let mut session = self.session.write().await;
223            let _ = session.save();
224        }
225        {
226            let mut cache = self.cache.write().await;
227            let count = cache.clear();
228            if count > 0 {
229                tracing::info!("[shutdown] cleared {count} cached file(s)");
230            }
231        }
232        crate::core::memory_guard::force_purge();
233    }
234}
lean_ctx/tools/server_lifecycle.rs

lean_ctx/tools/
server_lifecycle.rs
