lean_ctx/tools/
server_paths.rs

1use super::server::LeanCtxServer;
2use super::startup::{
3    has_project_marker, is_suspicious_root, maybe_derive_project_root_from_absolute,
4};
5
6impl LeanCtxServer {
7    pub fn checkpoint_interval_effective() -> usize {
8        if let Ok(v) = std::env::var("LEAN_CTX_CHECKPOINT_INTERVAL")
9            && let Ok(parsed) = v.trim().parse::<usize>()
10        {
11            return parsed;
12        }
13        let profile_interval = crate::core::profiles::active_profile()
14            .autonomy
15            .checkpoint_interval_effective();
16        if profile_interval > 0 {
17            return profile_interval as usize;
18        }
19        crate::core::config::Config::load().checkpoint_interval as usize
20    }
21
22    /// Resolves a (possibly relative) tool path against the session's project_root.
23    /// Absolute paths and "." are returned as-is. Relative paths like "src/main.rs"
24    /// are joined with project_root so tools work regardless of the server's cwd.
25    pub async fn resolve_path(&self, path: &str) -> Result<String, String> {
26        let normalized = crate::core::pathutil::normalize_tool_path(path);
27        if normalized.is_empty() || normalized == "." {
28            return Ok(normalized);
29        }
30        let p = std::path::Path::new(&normalized);
31
32        let (resolved, jail_root, extra_roots) = {
33            let session = self.session.read().await;
34            let jail_root = session
35                .project_root
36                .as_deref()
37                .or(session.shell_cwd.as_deref())
38                .unwrap_or(".")
39                .to_string();
40
41            // #707: a shell_cwd tracking a mid-session worktree switch
42            // (different git checkout) outranks the stale project_root — same
43            // precedence as core::path_resolve. Checked BEFORE the `p.exists()`
44            // probe below: that probe runs against the *process* CWD, which
45            // IDEs routinely set to the original project root, so it would
46            // short-circuit every relative path back to the stale checkout and
47            // the divergence rule could never apply.
48            let worktree_cwd = if p.is_absolute() {
49                None
50            } else {
51                session
52                    .project_root
53                    .as_deref()
54                    .zip(session.shell_cwd.as_deref())
55                    .filter(|(root, cwd)| {
56                        crate::core::path_resolve::shell_cwd_is_divergent_checkout(root, cwd)
57                    })
58                    .map(|(_, cwd)| std::path::Path::new(cwd).join(&normalized))
59            };
60
61            let resolved = if let Some(overridden) = worktree_cwd {
62                overridden
63            } else if p.is_absolute() || p.exists() {
64                std::path::PathBuf::from(&normalized)
65            } else if let Some(ref root) = session.project_root {
66                let joined = std::path::Path::new(root).join(&normalized);
67                if joined.exists() {
68                    joined
69                } else if let Some(ref cwd) = session.shell_cwd {
70                    std::path::Path::new(cwd).join(&normalized)
71                } else {
72                    std::path::Path::new(&jail_root).join(&normalized)
73                }
74            } else if let Some(ref cwd) = session.shell_cwd {
75                std::path::Path::new(cwd).join(&normalized)
76            } else {
77                std::path::Path::new(&jail_root).join(&normalized)
78            };
79
80            // Session-scoped trusted roots (MCP roots/list, config extra_roots,
81            // git worktrees) must widen the jail for an explicit path (#403).
82            (resolved, jail_root, session.extra_roots.clone())
83        };
84
85        let jail_root_path = std::path::Path::new(&jail_root);
86        let jailed = match crate::core::pathjail::jail_path_with_roots(
87            &resolved,
88            jail_root_path,
89            &extra_roots,
90        ) {
91            Ok(p) => p,
92            Err(e) => {
93                if p.is_absolute() {
94                    if let Some(new_root) = maybe_derive_project_root_from_absolute(&resolved) {
95                        let cfg_allow = std::env::var("LEAN_CTX_ALLOW_REROOT").map_or_else(
96                            |_| crate::core::config::Config::load().allow_auto_reroot,
97                            |v| v == "1" || v == "true",
98                        );
99                        let candidate_under_jail = resolved.starts_with(jail_root_path);
100                        // #580/#649: when the MCP server was launched from an
101                        // agent/IDE config dir (e.g. ~/.copilot) or a markerless
102                        // client cwd (e.g. WSL VS Code starting in /mnt/c/Users),
103                        // that jail is not a real project boundary. The derived
104                        // root already carries a project marker, so correcting to
105                        // it is a root fix, not a jail weakening. Real project
106                        // roots and trusted startup roots still keep the
107                        // conservative gate.
108                        let allow_reroot = if candidate_under_jail {
109                            false
110                        } else if is_suspicious_root(jail_root_path)
111                            || (self.startup_project_root.is_none()
112                                && !has_project_marker(jail_root_path))
113                        {
114                            true
115                        } else if !cfg_allow {
116                            false
117                        } else if let Some(ref trusted_root) = self.startup_project_root {
118                            std::path::Path::new(trusted_root) == new_root.as_path()
119                        } else {
120                            !has_project_marker(jail_root_path)
121                        };
122
123                        if allow_reroot {
124                            let mut session = self.session.write().await;
125                            let new_root_str = new_root.to_string_lossy().to_string();
126                            session.project_root = Some(new_root_str.clone());
127                            session.shell_cwd = self
128                                .startup_shell_cwd
129                                .as_ref()
130                                .filter(|cwd| std::path::Path::new(cwd).starts_with(&new_root))
131                                .cloned()
132                                .or_else(|| Some(new_root_str.clone()));
133                            let _ = session.save();
134
135                            crate::core::pathjail::jail_path_with_roots(
136                                &resolved,
137                                &new_root,
138                                &extra_roots,
139                            )?
140                        } else {
141                            return Err(e);
142                        }
143                    } else {
144                        return Err(e);
145                    }
146                } else {
147                    return Err(e);
148                }
149            }
150        };
151
152        crate::core::io_boundary::check_secret_path_for_tool("resolve_path", &jailed)?;
153
154        Ok(crate::core::pathutil::normalize_tool_path(
155            &jailed.to_string_lossy().replace('\\', "/"),
156        ))
157    }
158
159    /// Like `resolve_path`, but returns the original path on failure instead of an error.
160    pub async fn resolve_path_or_passthrough(&self, path: &str) -> String {
161        self.resolve_path(path)
162            .await
163            .unwrap_or_else(|_| path.to_string())
164    }
165}
lean_ctx/tools/server_paths.rs

lean_ctx/tools/
server_paths.rs
