1pub mod autonomy;
2pub mod ctx_agent;
3pub mod ctx_analyze;
4pub mod ctx_architecture;
5pub mod ctx_artifacts;
6pub mod ctx_benchmark;
7pub mod ctx_callgraph;
8pub mod ctx_compile;
9pub mod ctx_compose;
10pub mod ctx_compress;
11pub mod ctx_compress_memory;
12pub mod ctx_context;
13pub mod ctx_control;
14pub mod ctx_cost;
15pub mod ctx_dedup;
16pub mod ctx_delta;
17pub mod ctx_discover;
18pub mod ctx_edit;
19pub mod ctx_execute;
20pub mod ctx_expand;
21pub mod ctx_feedback;
22pub mod ctx_fill;
23pub mod ctx_gain;
24pub mod ctx_glob;
25pub mod ctx_graph;
26pub mod ctx_graph_diagram;
27pub mod ctx_graph_diff;
28pub mod ctx_graph_primitives;
29pub mod ctx_handoff;
30pub mod ctx_heatmap;
31pub mod ctx_impact;
32pub mod ctx_index;
33pub mod ctx_intent;
34pub mod ctx_knowledge;
35pub mod ctx_knowledge_relations;
36pub mod ctx_metrics;
37pub mod ctx_multi_read;
38pub mod ctx_multi_repo;
39pub mod ctx_outline;
40pub mod ctx_overview;
41pub mod ctx_pack;
42pub mod ctx_package;
43pub mod ctx_plan;
44pub mod ctx_plugins;
45pub mod ctx_prefetch;
46pub mod ctx_preload;
47pub mod ctx_proof;
48pub mod ctx_provider;
49pub mod ctx_read;
50pub mod ctx_refactor;
51pub mod ctx_repomap;
52pub mod ctx_response;
53pub mod ctx_review;
54pub mod ctx_routes;
55pub mod ctx_rules;
56pub mod ctx_search;
57pub mod ctx_semantic_search;
58pub mod ctx_session;
59pub mod ctx_share;
60pub mod ctx_shell;
61pub mod ctx_skillify;
62pub mod ctx_smart_read;
63pub mod ctx_smells;
64pub mod ctx_summary;
65pub mod ctx_symbol;
66pub mod ctx_task;
67pub mod ctx_tools;
68pub mod ctx_tree;
69pub mod ctx_verify;
70pub mod ctx_workflow;
71pub(crate) mod edit_recovery;
72pub(crate) mod knowledge_shared;
73pub mod registered;
74pub(crate) mod walk_guard;
75
76mod server;
77mod server_lifecycle;
78mod server_metrics;
79mod server_paths;
80pub(crate) mod startup;
81
82pub use server::*;
83pub use startup::create_server;
84
85#[cfg(test)]
86mod resolve_path_tests {
87 use super::startup::canonicalize_path;
88 use super::*;
89
90 fn create_git_root(path: &std::path::Path) -> String {
91 std::fs::create_dir_all(path.join(".git")).unwrap();
92 canonicalize_path(path)
93 }
94
95 #[cfg(not(feature = "no-jail"))]
96 #[tokio::test]
97 async fn resolve_path_can_reroot_to_trusted_startup_root_when_session_root_is_stale() {
98 std::env::set_var("LEAN_CTX_ALLOW_REROOT", "1");
99 let tmp = tempfile::tempdir().unwrap();
100 let stale = tmp.path().join("stale");
101 let real = tmp.path().join("real");
102 std::fs::create_dir_all(&stale).unwrap();
103 let real_root = create_git_root(&real);
104 std::fs::write(real.join("a.txt"), "ok").unwrap();
105
106 let server = LeanCtxServer::new_with_startup(
107 None,
108 Some(real.as_path()),
109 SessionMode::Personal,
110 "default",
111 "default",
112 );
113 {
114 let mut session = server.session.write().await;
115 session.project_root = Some(stale.to_string_lossy().to_string());
116 session.shell_cwd = Some(stale.to_string_lossy().to_string());
117 }
118
119 let out = server
120 .resolve_path(&real.join("a.txt").to_string_lossy())
121 .await
122 .unwrap();
123
124 assert!(out.ends_with("/a.txt"));
125
126 let session = server.session.read().await;
127 assert_eq!(session.project_root.as_deref(), Some(real_root.as_str()));
128 assert_eq!(session.shell_cwd.as_deref(), Some(real_root.as_str()));
129 }
130
131 #[cfg(not(feature = "no-jail"))]
132 #[tokio::test]
133 async fn resolve_path_rejects_absolute_path_outside_trusted_startup_root() {
134 let tmp = tempfile::tempdir().unwrap();
135 let stale = tmp.path().join("stale");
136 let root = tmp.path().join("root");
137 let other = tmp.path().join("other");
138 std::fs::create_dir_all(&stale).unwrap();
139 create_git_root(&root);
140 let _other_value = create_git_root(&other);
141 std::fs::write(other.join("b.txt"), "no").unwrap();
142
143 let server = LeanCtxServer::new_with_startup(
144 None,
145 Some(root.as_path()),
146 SessionMode::Personal,
147 "default",
148 "default",
149 );
150 {
151 let mut session = server.session.write().await;
152 session.project_root = Some(stale.to_string_lossy().to_string());
153 session.shell_cwd = Some(stale.to_string_lossy().to_string());
154 }
155
156 let err = server
157 .resolve_path(&other.join("b.txt").to_string_lossy())
158 .await
159 .unwrap_err();
160 assert!(err.contains("path escapes project root"));
161
162 let session = server.session.read().await;
163 assert_eq!(
164 session.project_root.as_deref(),
165 Some(stale.to_string_lossy().as_ref())
166 );
167 }
168
169 #[tokio::test]
170 #[allow(clippy::await_holding_lock)]
171 async fn startup_prefers_workspace_scoped_session_over_global_latest() {
172 let _lock = crate::core::data_dir::test_env_lock();
173 let _data = tempfile::tempdir().unwrap();
174 let _tmp = tempfile::tempdir().unwrap();
175
176 std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
177
178 let repo_a = _tmp.path().join("repo-a");
179 let repo_b = _tmp.path().join("repo-b");
180 let root_a = create_git_root(&repo_a);
181 let root_b = create_git_root(&repo_b);
182
183 let mut session_b = crate::core::session::SessionState::new();
184 session_b.project_root = Some(root_b.clone());
185 session_b.shell_cwd = Some(root_b.clone());
186 session_b.set_task("repo-b task", None);
187 session_b.save().unwrap();
188
189 std::thread::sleep(std::time::Duration::from_millis(50));
190
191 let mut session_a = crate::core::session::SessionState::new();
192 session_a.project_root = Some(root_a.clone());
193 session_a.shell_cwd = Some(root_a.clone());
194 session_a.set_task("repo-a latest task", None);
195 session_a.save().unwrap();
196
197 let server = LeanCtxServer::new_with_startup(
198 None,
199 Some(repo_b.as_path()),
200 SessionMode::Personal,
201 "default",
202 "default",
203 );
204 std::env::remove_var("LEAN_CTX_DATA_DIR");
205
206 let session = server.session.read().await;
207 assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
208 assert_eq!(session.shell_cwd.as_deref(), Some(root_b.as_str()));
209 assert_eq!(
210 session.task.as_ref().map(|t| t.description.as_str()),
211 Some("repo-b task")
212 );
213 }
214
215 #[tokio::test]
216 #[allow(clippy::await_holding_lock)]
217 async fn startup_creates_fresh_session_for_new_workspace_and_preserves_subdir_cwd() {
218 let _lock = crate::core::data_dir::test_env_lock();
219 let _data = tempfile::tempdir().unwrap();
220 let _tmp = tempfile::tempdir().unwrap();
221
222 std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
223
224 let repo_a = _tmp.path().join("repo-a");
225 let repo_b = _tmp.path().join("repo-b");
226 let repo_b_src = repo_b.join("src");
227 let root_a = create_git_root(&repo_a);
228 let root_b = create_git_root(&repo_b);
229 std::fs::create_dir_all(&repo_b_src).unwrap();
230 let repo_b_src_value = canonicalize_path(&repo_b_src);
231
232 let mut session_a = crate::core::session::SessionState::new();
233 session_a.project_root = Some(root_a.clone());
234 session_a.shell_cwd = Some(root_a.clone());
235 session_a.set_task("repo-a latest task", None);
236 let old_id = session_a.id.clone();
237 session_a.save().unwrap();
238
239 let server = LeanCtxServer::new_with_startup(
240 None,
241 Some(repo_b_src.as_path()),
242 SessionMode::Personal,
243 "default",
244 "default",
245 );
246 std::env::remove_var("LEAN_CTX_DATA_DIR");
247
248 let session = server.session.read().await;
249 assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
250 assert_eq!(
251 session.shell_cwd.as_deref(),
252 Some(repo_b_src_value.as_str())
253 );
254 assert!(session.task.is_none());
255 assert_ne!(session.id, old_id);
256 }
257
258 #[cfg(not(feature = "no-jail"))]
259 #[tokio::test]
260 async fn resolve_path_does_not_auto_update_when_current_root_is_real_project() {
261 let tmp = tempfile::tempdir().unwrap();
262 let root = tmp.path().join("root");
263 let other = tmp.path().join("other");
264 let root_value = create_git_root(&root);
265 create_git_root(&other);
266 std::fs::write(other.join("b.txt"), "no").unwrap();
267
268 let root_str = root.to_string_lossy().to_string();
269 let server = LeanCtxServer::new_with_project_root(Some(&root_str));
270
271 let err = server
272 .resolve_path(&other.join("b.txt").to_string_lossy())
273 .await
274 .unwrap_err();
275 assert!(err.contains("path escapes project root"));
276
277 let session = server.session.read().await;
278 assert_eq!(session.project_root.as_deref(), Some(root_value.as_str()));
279 }
280}