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        Self {
113            cache: Arc::new(RwLock::new(SessionCache::new())),
114            session,
115            tool_calls: Arc::new(RwLock::new(Vec::new())),
116            call_count: Arc::new(AtomicUsize::new(0)),
117            cache_ttl_secs: ttl,
118            last_call: Arc::new(RwLock::new(Instant::now())),
119            agent_id: Arc::new(RwLock::new(None)),
120            client_name: Arc::new(RwLock::new(String::new())),
121            autonomy: Arc::new(autonomy::AutonomyState::new()),
122            loop_detector: Arc::new(RwLock::new(
123                crate::core::loop_detection::LoopDetector::with_config(
124                    &crate::core::config::Config::load().loop_detection,
125                ),
126            )),
127            workflow: Arc::new(RwLock::new(
128                crate::core::workflow::load_active().ok().flatten(),
129            )),
130            ledger: Arc::new(RwLock::new(
131                crate::core::context_ledger::ContextLedger::load(),
132            )),
133            pipeline_stats: Arc::new(RwLock::new(crate::core::pipeline::PipelineStats::new())),
134            session_mode,
135            workspace_id: if workspace_id.trim().is_empty() {
136                "default".to_string()
137            } else {
138                workspace_id.trim().to_string()
139            },
140            channel_id: if channel_id.trim().is_empty() {
141                "default".to_string()
142            } else {
143                channel_id.trim().to_string()
144            },
145            context_os,
146            context_ir: None,
147            registry: Some(std::sync::Arc::new(
148                crate::server::registry::build_registry(),
149            )),
150            rules_stale_checked: Arc::new(std::sync::atomic::AtomicBool::new(false)),
151            last_seen_event_id: Arc::new(std::sync::atomic::AtomicI64::new(0)),
152            startup_project_root: startup.project_root,
153            startup_shell_cwd: startup.shell_cwd,
154        }
155    }
156
157    /// Clears the cache and saves the session if the TTL idle threshold has been exceeded.
158    pub async fn check_idle_expiry(&self) {
159        if self.cache_ttl_secs == 0 {
160            return;
161        }
162        let last = *self.last_call.read().await;
163        if last.elapsed().as_secs() >= self.cache_ttl_secs {
164            {
165                let mut session = self.session.write().await;
166                let _ = session.save();
167            }
168            let mut cache = self.cache.write().await;
169            let count = cache.clear();
170            if count > 0 {
171                tracing::info!(
172                    "Cache auto-cleared after {}s idle ({count} file(s))",
173                    self.cache_ttl_secs
174                );
175            }
176        }
177        *self.last_call.write().await = Instant::now();
178    }
179
180    /// Aggressive cleanup on connection drop: save session, clear all caches, purge allocator.
181    pub async fn shutdown(&self) {
182        {
183            let mut session = self.session.write().await;
184            let _ = session.save();
185        }
186        {
187            let mut cache = self.cache.write().await;
188            let count = cache.clear();
189            if count > 0 {
190                tracing::info!("[shutdown] cleared {count} cached file(s)");
191            }
192        }
193        crate::core::memory_guard::force_purge();
194    }
195}
lean_ctx/tools/server_lifecycle.rs

lean_ctx/tools/
server_lifecycle.rs
