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 signature_help(
221        &mut self,
222        name: &str,
223        actor: &str,
224        path: &str,
225        line: u32,
226        character: u32,
227    ) -> DevelopmentResult<LanguageResponse> {
228        self.position_request(name, actor, "signatureHelp", path, |client| {
229            client.signature_help(path, line, character)
230        })
231    }
232
233    pub fn code_actions(
234        &mut self,
235        name: &str,
236        actor: &str,
237        path: &str,
238        start: DiagnosticPosition,
239        end: DiagnosticPosition,
240        diagnostics: Vec<Value>,
241    ) -> DevelopmentResult<LanguageResponse> {
242        self.position_request(name, actor, "codeActions", path, |client| {
243            client.code_actions(path, start, end, &diagnostics)
244        })
245    }
246
247    pub fn formatting(
248        &mut self,
249        name: &str,
250        actor: &str,
251        path: &str,
252    ) -> DevelopmentResult<LanguageResponse> {
253        self.position_request(name, actor, "formatting", path, |client| {
254            client.formatting(path)
255        })
256    }
257
258    pub fn range_formatting(
259        &mut self,
260        name: &str,
261        actor: &str,
262        path: &str,
263        start: DiagnosticPosition,
264        end: DiagnosticPosition,
265    ) -> DevelopmentResult<LanguageResponse> {
266        self.position_request(name, actor, "rangeFormatting", path, |client| {
267            client.range_formatting(path, start, end)
268        })
269    }
270
271    pub fn semantic_tokens(
272        &mut self,
273        name: &str,
274        actor: &str,
275        path: &str,
276    ) -> DevelopmentResult<LanguageResponse> {
277        self.position_request(name, actor, "semanticTokens", path, |client| {
278            client.semantic_tokens(path)
279        })
280    }
281
282    pub fn rename(
283        &mut self,
284        name: &str,
285        actor: &str,
286        path: &str,
287        line: u32,
288        character: u32,
289        new_name: &str,
290    ) -> DevelopmentResult<LanguageResponse> {
291        self.position_request(name, actor, "rename", path, |client| {
292            client.rename(path, line, character, new_name)
293        })
294    }
295
296    fn position_request(
297        &mut self,
298        name: &str,
299        actor: &str,
300        operation: &str,
301        path: &str,
302        request: impl FnOnce(&mut LspClient) -> DevelopmentResult<LanguageResponse>,
303    ) -> DevelopmentResult<LanguageResponse> {
304        validate_actor(actor)?;
305        let response = request(self.client_mut(name)?)?;
306        self.record(
307            name,
308            actor,
309            operation,
310            (!path.is_empty()).then_some(path),
311            value_count(&response),
312        );
313        Ok(response)
314    }
315
316    pub fn events(&self, since: u64) -> Vec<LanguageServiceEvent> {
317        self.events
318            .iter()
319            .filter(|event| event.sequence > since)
320            .cloned()
321            .collect()
322    }
323
324    pub fn raw_request(
325        &mut self,
326        name: &str,
327        actor: &str,
328        method: &str,
329        params: Value,
330        timeout: Duration,
331    ) -> DevelopmentResult<LanguageResponse> {
332        validate_actor(actor)?;
333        let response = self
334            .client_mut(name)?
335            .raw_request(method, params, timeout)?;
336        self.record(name, actor, method, None, value_count(&response));
337        Ok(response)
338    }
339
340    fn record(
341        &mut self,
342        server: &str,
343        actor: &str,
344        operation: &str,
345        path: Option<&str>,
346        result_count: Option<usize>,
347    ) {
348        if self.events.len() == EVENT_LIMIT {
349            self.events.pop_front();
350        }
351        self.events.push_back(LanguageServiceEvent {
352            sequence: self.next_event,
353            server: server.into(),
354            actor: actor.into(),
355            operation: operation.into(),
356            path: path.map(str::to_string),
357            result_count,
358        });
359        self.next_event = self.next_event.saturating_add(1);
360    }
361}
362
363fn value_count(response: &LanguageResponse) -> Option<usize> {
364    response
365        .result
366        .as_array()
367        .map(Vec::len)
368        .or_else(|| response.result.as_object().map(serde_json::Map::len))
369}
370
371fn validate_name(name: &str) -> DevelopmentResult<()> {
372    if name.is_empty()
373        || name.len() > 64
374        || !name
375            .chars()
376            .all(|character| character.is_ascii_alphanumeric() || "-_".contains(character))
377    {
378        return Err(DevelopmentError::InvalidInput(
379            "language server names must be 1..=64 ASCII letters, digits, '-' or '_'".into(),
380        ));
381    }
382    Ok(())
383}
384
385fn validate_actor(actor: &str) -> DevelopmentResult<()> {
386    if actor.is_empty() || actor.len() > 256 || actor.chars().any(char::is_control) {
387        return Err(DevelopmentError::InvalidInput(
388            "language-service actor must contain 1..=256 non-control bytes".into(),
389        ));
390    }
391    Ok(())
392}
393
394fn validate_command(config: &LanguageServerConfig) -> DevelopmentResult<()> {
395    if config.command.is_empty()
396        || config.command.len() > 4096
397        || config.command.chars().any(char::is_control)
398        || config.arguments.len() > 64
399        || config.arguments.iter().any(|argument| {
400            argument.len() > 4096 || argument.chars().any(|character| character == '\0')
401        })
402    {
403        return Err(DevelopmentError::InvalidInput(
404            "language server command or arguments are invalid".into(),
405        ));
406    }
407    Ok(())
408}
409
410#[cfg(test)]
411mod tests {
412    use super::*;
413    use std::process::Command;
414    use std::sync::atomic::{AtomicU64, Ordering};
415
416    static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
417
418    #[test]
419    fn language_service_configuration_fails_closed() {
420        assert!(validate_name("rust").is_ok());
421        assert!(validate_name("../rust").is_err());
422        assert!(
423            validate_command(&LanguageServerConfig {
424                command: "rust-analyzer".into(),
425                arguments: Vec::new()
426            })
427            .is_ok()
428        );
429        assert!(validate_actor("embedded-agent-1").is_ok());
430        assert!(validate_actor("bad\nactor").is_err());
431    }
432
433    #[test]
434    fn shared_rust_language_service_serves_multiple_actors() {
435        if !Command::new("rust-analyzer")
436            .arg("--version")
437            .output()
438            .is_ok_and(|output| output.status.success())
439        {
440            return;
441        }
442        let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
443        let root = std::env::temp_dir().join(format!(
444            "glass-shared-lsp-{}-{sequence}",
445            std::process::id()
446        ));
447        std::fs::create_dir_all(root.join("src")).unwrap();
448        std::fs::write(
449            root.join("Cargo.toml"),
450            "[package]\nname='shared_lsp_fixture'\nversion='0.1.0'\nedition='2024'\n",
451        )
452        .unwrap();
453        std::fs::write(
454            root.join("src/lib.rs"),
455            "pub fn value() -> u32 { 42 }\npub fn use_value() { val }\n",
456        )
457        .unwrap();
458        let mut service = LanguageService::new(&root).unwrap();
459        service.start_rust_analyzer().unwrap();
460        let response = service
461            .completion("rust", "human", "src/lib.rs", 2, 25)
462            .unwrap();
463        assert_eq!(response.method, "textDocument/completion");
464        let hover = service
465            .hover("rust", "embedded-agent", "src/lib.rs", 1, 8)
466            .unwrap();
467        assert_eq!(hover.method, "textDocument/hover");
468        assert_eq!(service.names().collect::<Vec<_>>(), vec!["rust"]);
469        assert_eq!(service.events(0).len(), 3);
470        service.stop("rust").unwrap();
471        drop(service);
472        std::fs::remove_dir_all(root).unwrap();
473    }
474}