Skip to main content

glass_dev/
lsp.rs

1//! Shared resident language-service ownership for humans and agents.
2
3use crate::development::{
4    DevelopmentError, DevelopmentResult, DiagnosticPosition, LanguageDiagnostic, LanguageResponse,
5    LspClient,
6};
7use serde::{Deserialize, Serialize};
8use serde_json::Value;
9use std::collections::{BTreeMap, VecDeque};
10use std::path::{Path, PathBuf};
11use std::time::Duration;
12
13const EVENT_LIMIT: usize = 512;
14
15#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
16#[serde(rename_all = "camelCase")]
17pub struct LanguageServerConfig {
18    pub command: String,
19    #[serde(default)]
20    pub arguments: Vec<String>,
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
24#[serde(rename_all = "camelCase")]
25pub struct LanguageServiceEvent {
26    pub sequence: u64,
27    pub server: String,
28    pub actor: String,
29    pub operation: String,
30    pub path: Option<String>,
31    pub result_count: Option<usize>,
32}
33
34/// One shared set of persistent language servers for the workspace.
35pub struct LanguageService {
36    root: PathBuf,
37    servers: BTreeMap<String, LspClient>,
38    events: VecDeque<LanguageServiceEvent>,
39    next_event: u64,
40}
41
42impl LanguageService {
43    pub fn new(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
44        Ok(Self {
45            root: std::fs::canonicalize(root)?,
46            servers: BTreeMap::new(),
47            events: VecDeque::new(),
48            next_event: 1,
49        })
50    }
51
52    pub fn start(&mut self, name: &str, config: &LanguageServerConfig) -> DevelopmentResult<()> {
53        validate_name(name)?;
54        validate_command(config)?;
55        if self.servers.contains_key(name) {
56            return Err(DevelopmentError::Conflict(format!(
57                "language server {name} is already running"
58            )));
59        }
60        let client = LspClient::spawn(&self.root, &config.command, &config.arguments)?;
61        self.servers.insert(name.into(), client);
62        self.record(name, "system", "started", None, None);
63        Ok(())
64    }
65
66    pub fn start_rust_analyzer(&mut self) -> DevelopmentResult<()> {
67        self.start(
68            "rust",
69            &LanguageServerConfig {
70                command: "rust-analyzer".into(),
71                arguments: Vec::new(),
72            },
73        )
74    }
75
76    pub fn stop(&mut self, name: &str) -> DevelopmentResult<()> {
77        self.servers
78            .remove(name)
79            .ok_or_else(|| DevelopmentError::NotFound(format!("language server {name}")))?;
80        self.record(name, "system", "stopped", None, None);
81        Ok(())
82    }
83
84    pub fn names(&self) -> impl Iterator<Item = &str> {
85        self.servers.keys().map(String::as_str)
86    }
87
88    pub fn client_mut(&mut self, name: &str) -> DevelopmentResult<&mut LspClient> {
89        self.servers
90            .get_mut(name)
91            .ok_or_else(|| DevelopmentError::NotFound(format!("language server {name}")))
92    }
93
94    pub fn diagnostics(
95        &mut self,
96        name: &str,
97        actor: &str,
98        path: &str,
99    ) -> DevelopmentResult<Vec<LanguageDiagnostic>> {
100        validate_actor(actor)?;
101        let diagnostics = self.client_mut(name)?.diagnostics(path)?;
102        self.record(
103            name,
104            actor,
105            "diagnostics",
106            Some(path),
107            Some(diagnostics.len()),
108        );
109        Ok(diagnostics)
110    }
111
112    pub fn completion(
113        &mut self,
114        name: &str,
115        actor: &str,
116        path: &str,
117        line: u32,
118        character: u32,
119    ) -> DevelopmentResult<LanguageResponse> {
120        validate_actor(actor)?;
121        let response = self.client_mut(name)?.completion(path, line, character)?;
122        self.record(
123            name,
124            actor,
125            "completion",
126            Some(path),
127            value_count(&response),
128        );
129        Ok(response)
130    }
131
132    pub fn hover(
133        &mut self,
134        name: &str,
135        actor: &str,
136        path: &str,
137        line: u32,
138        character: u32,
139    ) -> DevelopmentResult<LanguageResponse> {
140        validate_actor(actor)?;
141        let response = self.client_mut(name)?.hover(path, line, character)?;
142        self.record(name, actor, "hover", Some(path), value_count(&response));
143        Ok(response)
144    }
145
146    pub fn definition(
147        &mut self,
148        name: &str,
149        actor: &str,
150        path: &str,
151        line: u32,
152        character: u32,
153    ) -> DevelopmentResult<LanguageResponse> {
154        self.position_request(name, actor, "definition", path, |client| {
155            client.definition(path, line, character)
156        })
157    }
158
159    pub fn declaration(
160        &mut self,
161        name: &str,
162        actor: &str,
163        path: &str,
164        line: u32,
165        character: u32,
166    ) -> DevelopmentResult<LanguageResponse> {
167        self.position_request(name, actor, "declaration", path, |client| {
168            client.declaration(path, line, character)
169        })
170    }
171
172    pub fn implementation(
173        &mut self,
174        name: &str,
175        actor: &str,
176        path: &str,
177        line: u32,
178        character: u32,
179    ) -> DevelopmentResult<LanguageResponse> {
180        self.position_request(name, actor, "implementation", path, |client| {
181            client.implementation(path, line, character)
182        })
183    }
184
185    pub fn references(
186        &mut self,
187        name: &str,
188        actor: &str,
189        path: &str,
190        line: u32,
191        character: u32,
192    ) -> DevelopmentResult<LanguageResponse> {
193        self.position_request(name, actor, "references", path, |client| {
194            client.references(path, line, character)
195        })
196    }
197
198    pub fn document_symbols(
199        &mut self,
200        name: &str,
201        actor: &str,
202        path: &str,
203    ) -> DevelopmentResult<LanguageResponse> {
204        self.position_request(name, actor, "documentSymbols", path, |client| {
205            client.document_symbols(path)
206        })
207    }
208
209    pub fn workspace_symbols(
210        &mut self,
211        name: &str,
212        actor: &str,
213        query: &str,
214    ) -> DevelopmentResult<LanguageResponse> {
215        self.position_request(name, actor, "workspaceSymbols", "", |client| {
216            client.workspace_symbols(query)
217        })
218    }
219
220    pub fn inlay_hints(
221        &mut self,
222        name: &str,
223        actor: &str,
224        path: &str,
225    ) -> DevelopmentResult<LanguageResponse> {
226        self.position_request(name, actor, "inlayHints", path, |client| {
227            client.inlay_hints(path)
228        })
229    }
230
231    pub fn signature_help(
232        &mut self,
233        name: &str,
234        actor: &str,
235        path: &str,
236        line: u32,
237        character: u32,
238    ) -> DevelopmentResult<LanguageResponse> {
239        self.position_request(name, actor, "signatureHelp", path, |client| {
240            client.signature_help(path, line, character)
241        })
242    }
243
244    pub fn code_actions(
245        &mut self,
246        name: &str,
247        actor: &str,
248        path: &str,
249        start: DiagnosticPosition,
250        end: DiagnosticPosition,
251        diagnostics: Vec<Value>,
252    ) -> DevelopmentResult<LanguageResponse> {
253        self.position_request(name, actor, "codeActions", path, |client| {
254            client.code_actions(path, start, end, &diagnostics)
255        })
256    }
257
258    pub fn formatting(
259        &mut self,
260        name: &str,
261        actor: &str,
262        path: &str,
263    ) -> DevelopmentResult<LanguageResponse> {
264        self.position_request(name, actor, "formatting", path, |client| {
265            client.formatting(path)
266        })
267    }
268
269    pub fn range_formatting(
270        &mut self,
271        name: &str,
272        actor: &str,
273        path: &str,
274        start: DiagnosticPosition,
275        end: DiagnosticPosition,
276    ) -> DevelopmentResult<LanguageResponse> {
277        self.position_request(name, actor, "rangeFormatting", path, |client| {
278            client.range_formatting(path, start, end)
279        })
280    }
281
282    pub fn semantic_tokens(
283        &mut self,
284        name: &str,
285        actor: &str,
286        path: &str,
287    ) -> DevelopmentResult<LanguageResponse> {
288        self.position_request(name, actor, "semanticTokens", path, |client| {
289            client.semantic_tokens(path)
290        })
291    }
292
293    pub fn rename(
294        &mut self,
295        name: &str,
296        actor: &str,
297        path: &str,
298        line: u32,
299        character: u32,
300        new_name: &str,
301    ) -> DevelopmentResult<LanguageResponse> {
302        self.position_request(name, actor, "rename", path, |client| {
303            client.rename(path, line, character, new_name)
304        })
305    }
306
307    fn position_request(
308        &mut self,
309        name: &str,
310        actor: &str,
311        operation: &str,
312        path: &str,
313        request: impl FnOnce(&mut LspClient) -> DevelopmentResult<LanguageResponse>,
314    ) -> DevelopmentResult<LanguageResponse> {
315        validate_actor(actor)?;
316        let response = request(self.client_mut(name)?)?;
317        self.record(
318            name,
319            actor,
320            operation,
321            (!path.is_empty()).then_some(path),
322            value_count(&response),
323        );
324        Ok(response)
325    }
326
327    pub fn events(&self, since: u64) -> Vec<LanguageServiceEvent> {
328        self.events
329            .iter()
330            .filter(|event| event.sequence > since)
331            .cloned()
332            .collect()
333    }
334
335    pub fn raw_request(
336        &mut self,
337        name: &str,
338        actor: &str,
339        method: &str,
340        params: Value,
341        timeout: Duration,
342    ) -> DevelopmentResult<LanguageResponse> {
343        validate_actor(actor)?;
344        let response = self
345            .client_mut(name)?
346            .raw_request(method, params, timeout)?;
347        self.record(name, actor, method, None, value_count(&response));
348        Ok(response)
349    }
350
351    fn record(
352        &mut self,
353        server: &str,
354        actor: &str,
355        operation: &str,
356        path: Option<&str>,
357        result_count: Option<usize>,
358    ) {
359        if self.events.len() == EVENT_LIMIT {
360            self.events.pop_front();
361        }
362        self.events.push_back(LanguageServiceEvent {
363            sequence: self.next_event,
364            server: server.into(),
365            actor: actor.into(),
366            operation: operation.into(),
367            path: path.map(str::to_string),
368            result_count,
369        });
370        self.next_event = self.next_event.saturating_add(1);
371    }
372}
373
374fn value_count(response: &LanguageResponse) -> Option<usize> {
375    response
376        .result
377        .as_array()
378        .map(Vec::len)
379        .or_else(|| response.result.as_object().map(serde_json::Map::len))
380}
381
382fn validate_name(name: &str) -> DevelopmentResult<()> {
383    if name.is_empty()
384        || name.len() > 64
385        || !name
386            .chars()
387            .all(|character| character.is_ascii_alphanumeric() || "-_".contains(character))
388    {
389        return Err(DevelopmentError::InvalidInput(
390            "language server names must be 1..=64 ASCII letters, digits, '-' or '_'".into(),
391        ));
392    }
393    Ok(())
394}
395
396fn validate_actor(actor: &str) -> DevelopmentResult<()> {
397    if actor.is_empty() || actor.len() > 256 || actor.chars().any(char::is_control) {
398        return Err(DevelopmentError::InvalidInput(
399            "language-service actor must contain 1..=256 non-control bytes".into(),
400        ));
401    }
402    Ok(())
403}
404
405fn validate_command(config: &LanguageServerConfig) -> DevelopmentResult<()> {
406    if config.command.is_empty()
407        || config.command.len() > 4096
408        || config.command.chars().any(char::is_control)
409        || config.arguments.len() > 64
410        || config.arguments.iter().any(|argument| {
411            argument.len() > 4096 || argument.chars().any(|character| character == '\0')
412        })
413    {
414        return Err(DevelopmentError::InvalidInput(
415            "language server command or arguments are invalid".into(),
416        ));
417    }
418    Ok(())
419}
420
421#[cfg(test)]
422mod tests {
423    use super::*;
424    use std::process::Command;
425    use std::sync::atomic::{AtomicU64, Ordering};
426
427    static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
428
429    #[test]
430    fn language_service_configuration_fails_closed() {
431        assert!(validate_name("rust").is_ok());
432        assert!(validate_name("../rust").is_err());
433        assert!(
434            validate_command(&LanguageServerConfig {
435                command: "rust-analyzer".into(),
436                arguments: Vec::new()
437            })
438            .is_ok()
439        );
440        assert!(validate_actor("embedded-agent-1").is_ok());
441        assert!(validate_actor("bad\nactor").is_err());
442    }
443
444    #[test]
445    fn shared_rust_language_service_serves_multiple_actors() {
446        if !Command::new("rust-analyzer")
447            .arg("--version")
448            .output()
449            .is_ok_and(|output| output.status.success())
450        {
451            return;
452        }
453        let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
454        let root = std::env::temp_dir().join(format!(
455            "glass-shared-lsp-{}-{sequence}",
456            std::process::id()
457        ));
458        std::fs::create_dir_all(root.join("src")).unwrap();
459        std::fs::write(
460            root.join("Cargo.toml"),
461            "[package]\nname='shared_lsp_fixture'\nversion='0.1.0'\nedition='2024'\n",
462        )
463        .unwrap();
464        std::fs::write(
465            root.join("src/lib.rs"),
466            "pub fn value() -> u32 { 42 }\npub fn use_value() { val }\n",
467        )
468        .unwrap();
469        let mut service = LanguageService::new(&root).unwrap();
470        service.start_rust_analyzer().unwrap();
471        let response = service
472            .completion("rust", "human", "src/lib.rs", 2, 25)
473            .unwrap();
474        assert_eq!(response.method, "textDocument/completion");
475        let hover = service
476            .hover("rust", "embedded-agent", "src/lib.rs", 1, 8)
477            .unwrap();
478        assert_eq!(hover.method, "textDocument/hover");
479        assert_eq!(service.names().collect::<Vec<_>>(), vec!["rust"]);
480        assert_eq!(service.events(0).len(), 3);
481        service.stop("rust").unwrap();
482        drop(service);
483        std::fs::remove_dir_all(root).unwrap();
484    }
485}