Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(lsp): Configure language servers and add servers of one's own (#108)

l0ng-ai48ac2094fc62
diff --git a/Cargo.lock b/Cargo.lock
index d0cddcb9d..467975ef3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4031,6 +4031,7 @@ dependencies = [
"serde",
"serde_json",
"specta",
+ "specta-typescript",
"thiserror 2.0.21",
"tokio-util",
]
@@ -4221,6 +4222,7 @@ dependencies = [
"parking_lot",
"regex-lite",
"serde",
+ "serde_json",
"specta",
"toml 0.9.12+spec-1.1.0",
"tracing",
diff --git a/Cargo.toml b/Cargo.toml
index 37bed70fc..e35265ce3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,6 +46,7 @@ serde_json = "1"
toml = "0.9"
toml_edit = "0.25"
specta = { version = "=2.0.0-rc.25", features = ["derive"] }
+specta-typescript = "0.0.12"
# async & concurrency
tokio = { version = "1", features = ["rt-multi-thread", "macros", "sync", "time", "process", "io-util", "fs"] }
diff --git a/crates/ide-core/Cargo.toml b/crates/ide-core/Cargo.toml
index 14cf7ab3c..21618ba11 100644
--- a/crates/ide-core/Cargo.toml
+++ b/crates/ide-core/Cargo.toml
@@ -10,5 +10,6 @@ dunce.workspace = true
serde.workspace = true
serde_json.workspace = true
specta.workspace = true
+specta-typescript.workspace = true
thiserror.workspace = true
tokio-util.workspace = true
diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rs
index 435763832..ca94467e6 100644
--- a/crates/ide-core/src/settings.rs
+++ b/crates/ide-core/src/settings.rs
@@ -42,6 +42,9 @@ pub struct Settings {
/// Language servers / debug adapters at a user-chosen location, by the
/// command the language definition launches (`elixir-ls`, `codelldb`).
pub tools: BTreeMap<String, ToolSettings>,
+ /// Per language server, by name (`rust-analyzer`): launch and protocol
+ /// options on top of the language definition, or a server defined here.
+ pub language_servers: BTreeMap<String, LanguageServerSettings>,
/// Editor › Inspections profiles.
pub inspections: InspectionSettings,
/// Editor › Natural Languages › Spelling.
@@ -61,6 +64,58 @@ pub struct ToolSettings {
pub path: String,
}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(default, rename_all = "camelCase")]
+pub struct LanguageServerSettings {
+ /// `false` keeps the server from starting for any language.
+ pub enabled: bool,
+ /// Executable to launch instead of the definition's; required for a server
+ /// defined here (one with `languages`).
+ pub command: String,
+ /// Replaces the definition's arguments.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ #[specta(optional)]
+ pub args: Option<Vec<String>>,
+ /// Added to the server's environment.
+ pub env: BTreeMap<String, String>,
+ /// Merged over the definition's `initializationOptions` (sent once at startup).
+ #[serde(skip_serializing_if = "Option::is_none")]
+ #[specta(optional, type = Option<specta_typescript::Unknown>)]
+ pub initialization_options: Option<serde_json::Value>,
+ /// Answers the server's `workspace/configuration` requests; changes are pushed
+ /// with `workspace/didChangeConfiguration` without a restart.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ #[specta(optional, type = Option<specta_typescript::Unknown>)]
+ pub settings: Option<serde_json::Value>,
+ /// Language ids a server defined here serves (`python`); empty for the servers
+ /// of the language definitions.
+ pub languages: Vec<String>,
+ /// Files marking a workspace root for a server defined here (`pyproject.toml`).
+ pub root_markers: Vec<String>,
+}
+
+impl Default for LanguageServerSettings {
+ fn default() -> Self {
+ Self {
+ enabled: true,
+ command: String::new(),
+ args: None,
+ env: BTreeMap::new(),
+ initialization_options: None,
+ settings: None,
+ languages: Vec::new(),
+ root_markers: Vec::new(),
+ }
+ }
+}
+
+impl LanguageServerSettings {
+ /// A server defined in settings rather than by a language definition.
+ pub fn is_custom(&self) -> bool {
+ !self.languages.is_empty()
+ }
+}
+
impl Settings {
/// The configured executable for `command`, if any (`~/` not yet expanded).
pub fn tool_path(&self, command: &str) -> Option<&str> {
@@ -89,6 +144,7 @@ impl Default for Settings {
actions_on_save: ActionsOnSaveSettings::default(),
external_tools: Vec::new(),
tools: BTreeMap::new(),
+ language_servers: BTreeMap::new(),
inspections: InspectionSettings::default(),
spelling: SpellingSettings::default(),
ssh: SshSettings::default(),
diff --git a/crates/ide-host/src/ops/project.rs b/crates/ide-host/src/ops/project.rs
index 2e624f25c..b631f6be2 100644
--- a/crates/ide-host/src/ops/project.rs
+++ b/crates/ide-host/src/ops/project.rs
@@ -113,7 +113,7 @@ pub fn set_settings(
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
// A new interpreter / toolchain / server executable restarts the language servers it affects.
- if ["languages", "tools"].iter().any(|k| key == *k || key.starts_with(&format!("{k}."))) {
+ if ["languages", "tools", "languageServers"].iter().any(|k| key == *k || key.starts_with(&format!("{k}."))) {
for project in affected() {
let lsp = project.lsp.clone();
host.runtime.spawn(async move { lsp.reconfigure().await });
diff --git a/crates/ide-host/src/ops/tools.rs b/crates/ide-host/src/ops/tools.rs
index db0ab6651..be3d13733 100644
--- a/crates/ide-host/src/ops/tools.rs
+++ b/crates/ide-host/src/ops/tools.rs
@@ -26,6 +26,17 @@ fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
Ok(Tools::new(&data).with_custom_paths(custom).with_found_paths(found.into_iter().collect()))
}
+/// The language definitions plus the servers defined in the window's settings.
+fn languages(host: &Host, window: &str) -> Vec<ide_language::LanguageConfig> {
+ let settings = match host.project(window) {
+ Ok(project) => project.settings.effective(),
+ Err(_) => host.global_settings.effective(),
+ };
+ let mut langs = host.languages.all();
+ ide_sdk::apply::with_custom_servers(&mut langs, &settings);
+ langs
+}
+
fn join_err(e: impl std::fmt::Display) -> IdeError {
IdeError::internal(e.to_string())
}
@@ -40,7 +51,7 @@ fn reconfigure_servers(host: &Host) {
/// Status of every known language server / debug adapter and the languages using it.
pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
let tools = tools(host, window)?;
- let langs = host.languages.all();
+ let langs = languages(host, window);
tokio::task::spawn_blocking(move || tools.list(&langs)).await.map_err(join_err)
}
@@ -54,7 +65,7 @@ pub async fn tools_install(
on_event: Channel<InstallEvent>,
) -> IdeResult<ToolInfo> {
let tools = tools(host, window)?;
- let langs = host.languages.all();
+ let langs = languages(host, window);
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || {
tools.install(&name, &langs, &cancel, &|e| {
@@ -74,7 +85,7 @@ pub async fn tools_install(
/// Removes a tool the IDE installed.
pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResult<ToolInfo> {
let tools = tools(host, window)?;
- let langs = host.languages.all();
+ let langs = languages(host, window);
let info = tokio::task::spawn_blocking(move || tools.uninstall(&name, &langs)).await.map_err(join_err)??;
reconfigure_servers(host);
Ok(info)
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rs
index 869541659..ee92e219c 100644
--- a/crates/ide-host/src/project.rs
+++ b/crates/ide-host/src/project.rs
@@ -117,6 +117,7 @@ impl Host {
let data_dir = self.data_dir.clone();
lsp.set_config_hook(Box::new(move |cfg, server_root| {
let effective = settings.effective();
+ ide_sdk::apply::server_launch_overrides(cfg, &effective);
ide_sdk::apply::configure_server(cfg, &root, server_root, &effective);
if cfg.name == "jdtls" {
let bundles: Vec<PathBuf> =
@@ -149,6 +150,13 @@ impl Host {
);
ide_sdk::jdtls::launch_directly(cfg);
}
+ ide_sdk::apply::server_protocol_overrides(cfg, &effective);
+ }));
+ }
+ {
+ let settings = settings.clone();
+ lsp.set_servers_hook(Box::new(move |language, defined| {
+ ide_sdk::apply::language_servers(language.as_str(), defined, &settings.effective())
}));
}
{
diff --git a/crates/ide-language/Cargo.toml b/crates/ide-language/Cargo.toml
index 39207b942..12ff2717e 100644
--- a/crates/ide-language/Cargo.toml
+++ b/crates/ide-language/Cargo.toml
@@ -9,6 +9,7 @@ license.workspace = true
ide-core.workspace = true
ide-text.workspace = true
serde.workspace = true
+serde_json.workspace = true
specta.workspace = true
toml.workspace = true
tree-sitter.workspace = true
diff --git a/crates/ide-language/src/lib.rs b/crates/ide-language/src/lib.rs
index 6af20c66a..0a016a6d1 100644
--- a/crates/ide-language/src/lib.rs
+++ b/crates/ide-language/src/lib.rs
@@ -72,6 +72,10 @@ pub struct LanguageServerConfig {
/// JSON passed as `initializationOptions`.
#[serde(default)]
pub initialization_options: Option<toml::Value>,
+ /// Answers `workspace/configuration`; without it the sections are looked up
+ /// in `initialization_options`.
+ #[serde(default)]
+ pub settings: Option<serde_json::Value>,
/// Human hint shown when the binary is missing.
#[serde(default)]
pub install_hint: Option<String>,
diff --git a/crates/ide-lsp/src/handler.rs b/crates/ide-lsp/src/handler.rs
index c5df73986..35be7f5b8 100644
--- a/crates/ide-lsp/src/handler.rs
+++ b/crates/ide-lsp/src/handler.rs
@@ -125,13 +125,7 @@ impl ClientHandler {
}
fn configuration(&self, params: &Value) -> Value {
- let options = self
- .server
- .effective_config()
- .initialization_options
- .as_ref()
- .and_then(|v| serde_json::to_value(v).ok())
- .unwrap_or(Value::Null);
+ let options = all_settings(&self.server.effective_config());
let items = params.get("items").and_then(Value::as_array).cloned().unwrap_or_default();
Value::Array(
items
@@ -244,3 +238,29 @@ impl Handler for ClientHandler {
}
}
}
+
+/// What `workspace/configuration` sections are looked up in: the server's
+/// `initializationOptions` with its `settings` merged over them.
+pub(crate) fn all_settings(cfg: &ide_language::LanguageServerConfig) -> Value {
+ let mut out = cfg.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok()).unwrap_or(Value::Null);
+ if let Some(settings) = &cfg.settings {
+ merge(&mut out, settings.clone());
+ }
+ out
+}
+
+fn merge(base: &mut Value, layer: Value) {
+ match (base, layer) {
+ (Value::Object(base), Value::Object(layer)) => {
+ for (k, v) in layer {
+ match base.get_mut(&k) {
+ Some(existing) => merge(existing, v),
+ None => {
+ base.insert(k, v);
+ }
+ }
+ }
+ }
+ (base, layer) => *base = layer,
+ }
+}
diff --git a/crates/ide-lsp/src/inspect.rs b/crates/ide-lsp/src/inspect.rs
index 3aa6c645f..95f4fb626 100644
--- a/crates/ide-lsp/src/inspect.rs
+++ b/crates/ide-lsp/src/inspect.rs
@@ -65,8 +65,7 @@ impl LspManager {
/// run doesn't prompt to install every language it meets.
pub fn serves_path(&self, path: &Path) -> bool {
let lang = self.languages.detect(path, None);
- let Some(config) = self.languages.get(&lang) else { return false };
- config.language_servers.iter().any(|ls| {
+ self.language_servers(&lang).iter().any(|ls| {
let mut cfg = ls.clone();
if let Some(hook) = self.config_hook.read().clone() {
hook(&mut cfg, &self.project_root);
diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rs
index 9a0489acf..f003d36df 100644
--- a/crates/ide-lsp/src/lib.rs
+++ b/crates/ide-lsp/src/lib.rs
@@ -68,6 +68,9 @@ pub type ApplyEditHook = Arc<dyn Fn(WorkspaceEdit) -> bool + Send + Sync>;
/// settings before each launch; receives the server's workspace root.
pub type ConfigFn = dyn Fn(&mut LanguageServerConfig, &Path) + Send + Sync;
pub type ConfigHook = Arc<ConfigFn>;
+/// The servers a language uses, from its definition's list (user settings
+/// disable some and add others).
+pub type ServersFn = dyn Fn(&LanguageId, &[LanguageServerConfig]) -> Vec<LanguageServerConfig> + Send + Sync;
struct Attached {
server: Arc<Server>,
@@ -146,6 +149,7 @@ pub struct LspManager {
docs: Mutex<HashMap<DocId, DocState>>,
apply_edit_hook: RwLock<Option<ApplyEditHook>>,
config_hook: RwLock<Option<ConfigHook>>,
+ servers_hook: RwLock<Option<Arc<ServersFn>>>,
candidates_hook: RwLock<Option<Arc<CandidateFn>>>,
shutting_down: AtomicBool,
/// `window/showMessage` texts already surfaced; servers repeat them on every restart/reconfigure.
@@ -264,6 +268,7 @@ impl LspManager {
docs: Mutex::new(HashMap::new()),
apply_edit_hook: RwLock::new(None),
config_hook: RwLock::new(None),
+ servers_hook: RwLock::new(None),
candidates_hook: RwLock::new(None),
shutting_down: AtomicBool::new(false),
shown_messages: Mutex::new(HashSet::new()),
@@ -297,10 +302,9 @@ impl LspManager {
/// The servers serving `path`: every regular one, and each `fallback` one
/// only while all servers listed before it are missing.
fn servers_for(&self, language: &LanguageId, path: &Path) -> Vec<Arc<Server>> {
- let Some(cfg) = self.languages.get(language) else { return Vec::new() };
let mut out = Vec::new();
let mut available_before = false;
- for sc in &cfg.language_servers {
+ for sc in &self.language_servers(language) {
if sc.fallback && available_before {
continue;
}
@@ -311,8 +315,18 @@ impl LspManager {
out
}
+ /// The definitions of the servers `language` uses.
+ fn language_servers(&self, language: &LanguageId) -> Vec<LanguageServerConfig> {
+ let Some(cfg) = self.languages.get(language) else { return Vec::new() };
+ match self.servers_hook.read().clone() {
+ Some(hook) => hook(language, &cfg.language_servers),
+ None => cfg.language_servers,
+ }
+ }
+
/// A server turned out to be missing: attach the fallbacks it was hiding
- /// to the open documents (and start them).
+ /// to the open documents (and start them). Also attaches servers newly
+ /// enabled in settings.
fn attach_fallbacks(&self) {
let open: Vec<(DocId, LanguageId, PathBuf)> =
self.docs.lock().iter().map(|(id, d)| (*id, d.language.clone(), d.path.clone())).collect();
@@ -432,6 +446,14 @@ impl LspManager {
if let Err(e) = peer.notify("initialized", json!({})) {
tracing::warn!("{}: {e}", server.name);
}
+ // Servers that don't ask with `workspace/configuration` only learn settings this way.
+ let cfg = server.effective_config();
+ if cfg.settings.is_some()
+ && let Err(e) =
+ peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
+ {
+ tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
+ }
let run = Running { generation, peer: peer.clone(), caps: Arc::new(RwLock::new(caps)) };
// Publish readiness and (re)open attached documents atomically w.r.t. did_change.
@@ -1778,6 +1800,11 @@ impl LspManager {
*self.config_hook.write() = Some(Arc::from(hook));
}
+ /// Installed by `src-tauri` to apply the servers enabled / defined in settings.
+ pub fn set_servers_hook(&self, hook: Box<ServersFn>) {
+ *self.servers_hook.write() = Some(Arc::from(hook));
+ }
+
/// The server's base configuration with the settings hook applied.
fn configured(&self, server: &Server) -> LanguageServerConfig {
let mut cfg = server.config.clone();
@@ -1789,11 +1816,26 @@ impl LspManager {
/// Restarts running servers whose settings-derived configuration changed
/// (e.g. a new project interpreter); stopped ones pick it up on their next start.
+ /// A change of `settings` alone reaches a running server without a restart.
+ /// Servers no longer enabled stop; newly enabled ones attach to open documents.
pub async fn reconfigure(&self) {
+ self.stop_unlisted().await;
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
for s in servers {
let next = self.configured(&s);
- if next == s.effective_config() {
+ let current = s.effective_config();
+ if next == current {
+ continue;
+ }
+ let without_settings = |c: &LanguageServerConfig| LanguageServerConfig { settings: None, ..c.clone() };
+ if let Some(run) = s.running()
+ && without_settings(&next) == without_settings(&current)
+ {
+ s.set_effective_config(next);
+ let params = json!({ "settings": handler::all_settings(&s.effective_config()) });
+ if let Err(e) = run.peer.notify("workspace/didChangeConfiguration", params) {
+ tracing::debug!("{}: didChangeConfiguration: {e}", s.name);
+ }
continue;
}
match s.status() {
@@ -1815,6 +1857,96 @@ impl LspManager {
ide_core::event::ServerStatus::Stopped => {}
}
}
+ self.attach_fallbacks();
+ self.detach_shadowed_fallbacks().await;
+ }
+
+ /// A server enabled again shadows the fallbacks attached in its place: they
+ /// leave the open documents, and stop once no document uses them.
+ async fn detach_shadowed_fallbacks(&self) {
+ let open: Vec<(DocId, LanguageId, PathBuf)> =
+ self.docs.lock().iter().map(|(id, d)| (*id, d.language.clone(), d.path.clone())).collect();
+ let mut shadowed: Vec<(DocId, Vec<ide_core::ServerId>)> = Vec::new();
+ for (id, language, path) in open {
+ let configs = self.language_servers(&language);
+ let wanted = self.servers_for(&language, &path);
+ let docs = self.docs.lock();
+ let Some(d) = docs.get(&id) else { continue };
+ let gone: Vec<ide_core::ServerId> = d
+ .servers
+ .iter()
+ .filter(|a| {
+ !wanted.iter().any(|w| w.id == a.server.id)
+ && configs.iter().any(|c| c.fallback && c.name == a.server.name)
+ })
+ .map(|a| a.server.id)
+ .collect();
+ if !gone.is_empty() {
+ shadowed.push((id, gone));
+ }
+ }
+ if shadowed.is_empty() {
+ return;
+ }
+ let mut detached: Vec<Arc<Server>> = Vec::new();
+ {
+ let mut docs = self.docs.lock();
+ for (id, gone) in shadowed {
+ let Some(d) = docs.get_mut(&id) else { continue };
+ let (leaving, staying): (Vec<Attached>, Vec<Attached>) =
+ d.servers.drain(..).partition(|a| gone.contains(&a.server.id));
+ d.servers = staying;
+ for a in leaving {
+ if let Some(run) = a.server.running()
+ && a.opened_gen == Some(run.generation)
+ && run.caps.read().open_close
+ && let Err(e) =
+ run.peer.notify("textDocument/didClose", json!({ "textDocument": { "uri": d.uri } }))
+ {
+ tracing::debug!("{}: didClose: {e}", a.server.name);
+ }
+ self.sink.emit(ide_core::IdeEvent::Diagnostics {
+ path: d.path.clone().into(),
+ source: a.server.name.clone(),
+ items: Vec::new(),
+ });
+ if !detached.iter().any(|s| s.id == a.server.id) {
+ detached.push(a.server);
+ }
+ }
+ }
+ let in_use = |s: &Arc<Server>| docs.values().any(|d| d.servers.iter().any(|a| a.server.id == s.id));
+ detached.retain(|s| !in_use(s));
+ }
+ if detached.is_empty() {
+ return;
+ }
+ for s in &detached {
+ tracing::info!("{}: shadowed by an enabled server, stopping", s.name);
+ self.stop_instance(s, true).await;
+ }
+ self.servers.lock().retain(|s| !detached.iter().any(|d| d.id == s.id));
+ }
+
+ /// Stops and forgets the servers that none of their languages uses any more.
+ async fn stop_unlisted(&self) {
+ let servers: Vec<Arc<Server>> = self.servers.lock().clone();
+ let unlisted: Vec<Arc<Server>> = servers
+ .into_iter()
+ .filter(|s| !s.languages().iter().any(|l| self.language_servers(l).iter().any(|c| c.name == s.name)))
+ .collect();
+ if unlisted.is_empty() {
+ return;
+ }
+ for s in &unlisted {
+ tracing::info!("{}: no longer enabled, stopping", s.name);
+ self.stop_instance(s, true).await;
+ }
+ let gone = |s: &Arc<Server>| unlisted.iter().any(|u| u.id == s.id);
+ self.servers.lock().retain(|s| !gone(s));
+ for d in self.docs.lock().values_mut() {
+ d.servers.retain(|a| !gone(&a.server));
+ }
}
pub fn set_apply_edit_hook(&self, hook: Box<dyn Fn(WorkspaceEdit) -> bool + Send + Sync>) {
diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rs
index 98d7af078..9ca8e202a 100644
--- a/crates/ide-lsp/tests/mock_server.rs
+++ b/crates/ide-lsp/tests/mock_server.rs
@@ -203,6 +203,7 @@ fn server_cfg(name: &str) -> LanguageServerConfig {
env: Default::default(),
root_markers: vec!["mock.toml".into()],
initialization_options: Some(toml::Value::Table(toml::toml! { flag = true nested = { deep = 1 } })),
+ settings: None,
install_hint: Some(format!("install {name}")),
connect: None,
fallback: false,
@@ -795,6 +796,54 @@ async fn launch_error_fails_without_starting_the_server() {
assert!(!h.statuses("mock").contains(&ServerStatus::Crashed));
}
+#[tokio::test(flavor = "multi_thread")]
+async fn settings_changes_reach_servers_without_restarts() {
+ let h = harness(&[("mock", incremental_caps()), ("extra", incremental_caps())]);
+ let settings: Arc<Mutex<Option<Value>>> = Default::default();
+ let disabled: Arc<Mutex<Vec<String>>> = Default::default();
+ {
+ let settings = settings.clone();
+ h.mgr.set_config_hook(Box::new(move |cfg, _| cfg.settings = settings.lock().clone()));
+ }
+ {
+ let disabled = disabled.clone();
+ h.mgr.set_servers_hook(Box::new(move |_, defined| {
+ defined.iter().filter(|c| !disabled.lock().contains(&c.name)).cloned().collect()
+ }));
+ }
+ h.open("a.mk", "x");
+ h.wait_status("mock", ServerStatus::Ready).await;
+ h.wait_status("extra", ServerStatus::Ready).await;
+
+ // Only `settings` changed: pushed to the running server, which keeps running.
+ let s = h.launcher.state("mock");
+ *settings.lock() = Some(json!({ "nested": { "other": 2 } }));
+ h.mgr.reconfigure().await;
+ eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
+ assert_eq!(
+ s.notified("workspace/didChangeConfiguration")[0],
+ json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
+ );
+ assert_eq!(s.launches.load(Ordering::SeqCst), 1);
+ let cfg: Value = s
+ .peer()
+ .request("workspace/configuration", json!({ "items": [{ "section": "nested.other" }] }), None)
+ .await
+ .unwrap();
+ assert_eq!(cfg, json!([2]));
+
+ // Disabled: stopped and forgotten; enabled again: attached to the open document.
+ disabled.lock().push("extra".into());
+ h.mgr.reconfigure().await;
+ assert_eq!(h.mgr.servers().iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["mock"]);
+ assert_eq!(h.statuses("extra").last(), Some(&ServerStatus::Stopped));
+ disabled.lock().clear();
+ h.mgr.reconfigure().await;
+ h.wait_status("extra", ServerStatus::Ready).await;
+ eventually(|| h.launcher.state("extra").notified("textDocument/didOpen").len() == 2).await;
+ assert_eq!(s.launches.load(Ordering::SeqCst), 1);
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn fallback_servers_only_run_when_the_preferred_one_is_missing() {
// Preferred installed: the alternative is never started.
@@ -819,6 +868,40 @@ async fn fallback_servers_only_run_when_the_preferred_one_is_missing() {
assert!(h.mgr.hover(doc, Pos::new(0, 0), Default::default()).await.is_ok());
}
+#[tokio::test(flavor = "multi_thread")]
+async fn a_fallback_leaves_when_the_preferred_server_is_enabled_again() {
+ let h = harness_with_fallbacks(&[("main", incremental_caps()), ("alt", incremental_caps())], &["alt"]);
+ let disabled: Arc<Mutex<Vec<String>>> = Default::default();
+ {
+ let disabled = disabled.clone();
+ h.mgr.set_servers_hook(Box::new(move |_, defined| {
+ defined.iter().filter(|c| !disabled.lock().contains(&c.name)).cloned().collect()
+ }));
+ }
+ let (doc, path) = h.open("a.mk", "x");
+ let uri = uri_of(&path);
+ h.wait_status("main", ServerStatus::Ready).await;
+ assert!(h.statuses("alt").is_empty());
+
+ // Preferred disabled: the fallback takes over the open document.
+ disabled.lock().push("main".into());
+ h.mgr.reconfigure().await;
+ h.wait_status("alt", ServerStatus::Ready).await;
+ eventually(|| h.launcher.state("alt").docs.lock().contains_key(&uri)).await;
+ assert_eq!(h.mgr.servers().iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["alt"]);
+
+ // Enabled again: the fallback closes the document and stops.
+ disabled.lock().clear();
+ h.mgr.reconfigure().await;
+ h.wait_status("main", ServerStatus::Ready).await;
+ eventually(|| h.launcher.state("main").docs.lock().contains_key(&uri)).await;
+ assert!(!h.launcher.state("alt").notified("textDocument/didClose").is_empty());
+ assert_eq!(h.statuses("alt").last(), Some(&ServerStatus::Stopped));
+ assert_eq!(h.mgr.servers().iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["main"]);
+ assert!(h.mgr.hover(doc, Pos::new(0, 0), Default::default()).await.is_ok());
+ assert_eq!(h.launcher.state("alt").requested("textDocument/hover").len(), 0);
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn implementations_per_position() {
let caps = json!({ "textDocumentSync": 1, "implementationProvider": true });
diff --git a/crates/ide-lsp/tests/real_servers.rs b/crates/ide-lsp/tests/real_servers.rs
index e0bba0013..121bb0279 100644
--- a/crates/ide-lsp/tests/real_servers.rs
+++ b/crates/ide-lsp/tests/real_servers.rs
@@ -70,6 +70,7 @@ async fn missing_binary_is_reported_with_install_hint() {
env: Default::default(),
root_markers: vec![],
initialization_options: None,
+ settings: None,
install_hint: Some("npm i -g nope-ls".into()),
connect: None,
fallback: false,
@@ -198,6 +199,7 @@ async fn typescript_language_server_end_to_end() {
env: Default::default(),
root_markers: vec!["tsconfig.json".into()],
initialization_options: None,
+ settings: None,
install_hint: None,
connect: None,
fallback: false,
@@ -240,6 +242,7 @@ fn npm_server(tools: &Path, name: &str, bin: &str, init: Option<serde_json::Valu
env: Default::default(),
root_markers: vec!["package.json".into()],
initialization_options: init.map(|v| toml::Value::try_from(v).unwrap()),
+ settings: None,
install_hint: None,
connect: None,
fallback: false,
diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rs
index bca1225f5..54329bf35 100644
--- a/crates/ide-sdk/src/apply.rs
+++ b/crates/ide-sdk/src/apply.rs
@@ -5,8 +5,8 @@ use crate::discover::{project_venv_python, workspace_tsdk};
use crate::exec::{path_with, search_path};
use crate::{bin_dir, exe, venv_of};
use crate::{godot, vue};
-use ide_core::settings::Settings;
-use ide_language::LanguageServerConfig;
+use ide_core::settings::{LanguageServerSettings, Settings};
+use ide_language::{LanguageConfig, LanguageServerConfig};
use ide_run::RunConfig;
use serde_json::{Value, json};
use std::path::{Path, PathBuf};
@@ -302,6 +302,77 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
}
}
+/// The servers `language` uses after Settings › Language Servers: the
+/// definition's ones that aren't disabled, then the ones defined in settings for it.
+pub fn language_servers(language: &str, defined: &[LanguageServerConfig], s: &Settings) -> Vec<LanguageServerConfig> {
+ let enabled = |name: &str| s.language_servers.get(name).is_none_or(|ls| ls.enabled);
+ let mut out: Vec<LanguageServerConfig> = defined.iter().filter(|c| enabled(&c.name)).cloned().collect();
+ for (name, ls) in &s.language_servers {
+ if ls.enabled && ls.languages.iter().any(|l| l == language) && !out.iter().any(|c| &c.name == name) {
+ out.push(custom_server(name, ls));
+ }
+ }
+ out
+}
+
+/// Adds the servers defined in settings to the languages they serve (to list
+/// them with the tools); disabled ones stay so they can be turned back on.
+pub fn with_custom_servers(langs: &mut [LanguageConfig], s: &Settings) {
+ for (name, ls) in s.language_servers.iter().filter(|(_, ls)| ls.is_custom()) {
+ for lang in langs.iter_mut().filter(|l| ls.languages.iter().any(|id| id == l.id.as_str())) {
+ if !lang.language_servers.iter().any(|c| &c.name == name) {
+ lang.language_servers.push(custom_server(name, ls));
+ }
+ }
+ }
+}
+
+fn custom_server(name: &str, ls: &LanguageServerSettings) -> LanguageServerConfig {
+ LanguageServerConfig {
+ name: name.to_owned(),
+ command: ls.command.trim().to_owned(),
+ args: Vec::new(),
+ env: Default::default(),
+ root_markers: ls.root_markers.clone(),
+ initialization_options: None,
+ settings: None,
+ install_hint: Some(match ls.command.trim() {
+ "" => format!("Set the command of `{name}` in Settings › Language Servers"),
+ command => format!("`{command}` was not found: install it, or set its path in Settings › Language Servers"),
+ }),
+ connect: None,
+ fallback: false,
+ launch_error: None,
+ }
+}
+
+/// Command and arguments from Settings › Language Servers; applied before
+/// [`configure_server`] so toolchain adjustments (a custom path, JVM args) still follow.
+pub fn server_launch_overrides(cfg: &mut LanguageServerConfig, s: &Settings) {
+ let Some(ls) = s.language_servers.get(&cfg.name) else { return };
+ if let Some(command) = non_empty(ls.command.trim()) {
+ cfg.command = command.to_owned();
+ }
+ if let Some(args) = &ls.args {
+ cfg.args = args.clone();
+ }
+}
+
+/// Environment, `initializationOptions` and `workspace/configuration` settings
+/// from Settings › Language Servers; applied last so they win over derived values.
+pub fn server_protocol_overrides(cfg: &mut LanguageServerConfig, s: &Settings) {
+ let Some(ls) = s.language_servers.get(&cfg.name) else { return };
+ cfg.env.extend(ls.env.iter().map(|(k, v)| (k.clone(), v.clone())));
+ if let Some(options) = &ls.initialization_options {
+ merge_init_options(cfg, options.clone());
+ }
+ if let Some(settings) = &ls.settings {
+ let mut current = cfg.settings.take().filter(Value::is_object).unwrap_or_else(|| json!({}));
+ merge(&mut current, settings.clone());
+ cfg.settings = Some(current);
+ }
+}
+
/// vue-language-server loads TypeScript as a library (`--tsdk`, else its own
/// `require('typescript')`): the selected version, else its own, else the
/// project's — whichever still has the language-service API.
diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rs
index 57b899f18..fb6699609 100644
--- a/crates/ide-sdk/src/tests.rs
+++ b/crates/ide-sdk/src/tests.rs
@@ -28,6 +28,7 @@ fn server(name: &str) -> LanguageServerConfig {
env: BTreeMap::new(),
root_markers: vec![],
initialization_options: None,
+ settings: None,
install_hint: None,
connect: None,
fallback: false,
@@ -205,6 +206,59 @@ fn project_jdk_and_maven_settings() {
assert_eq!(project_jdk(tmp.path(), &s), None);
}
+#[test]
+fn language_server_settings_disable_add_and_override() {
+ use crate::apply::{language_servers, server_launch_overrides, server_protocol_overrides, with_custom_servers};
+ use ide_core::settings::LanguageServerSettings;
+ use serde_json::json;
+
+ let mut s = Settings::default();
+ s.language_servers.insert("pylsp".into(), LanguageServerSettings { enabled: false, ..Default::default() });
+ s.language_servers.insert(
+ "ruff".into(),
+ LanguageServerSettings {
+ command: "ruff".into(),
+ args: Some(vec!["server".into()]),
+ languages: vec!["python".into()],
+ root_markers: vec!["pyproject.toml".into()],
+ ..Default::default()
+ },
+ );
+ let defined = [server("basedpyright"), server("pylsp")];
+ let names = |v: Vec<LanguageServerConfig>| v.into_iter().map(|c| c.name).collect::<Vec<_>>();
+ assert_eq!(names(language_servers("python", &defined, &s)), ["basedpyright", "ruff"]);
+ assert_eq!(names(language_servers("rust", &[server("rust-analyzer")], &s)), ["rust-analyzer"]);
+
+ // Listed with the tools even while disabled.
+ let mut langs = ide_language::LanguageRegistry::load(None).unwrap().all();
+ with_custom_servers(&mut langs, &s);
+ let python = langs.iter().find(|l| l.id.as_str() == "python").unwrap();
+ let mut ruff = python.language_servers.iter().find(|c| c.name == "ruff").unwrap().clone();
+ assert_eq!(ruff.root_markers, ["pyproject.toml"]);
+ server_launch_overrides(&mut ruff, &s);
+ assert_eq!((ruff.command.as_str(), ruff.args.as_slice()), ("ruff", &["server".to_string()][..]));
+
+ s.language_servers.insert(
+ "rust-analyzer".into(),
+ LanguageServerSettings {
+ env: BTreeMap::from([("RA_LOG".into(), "info".into())]),
+ initialization_options: Some(json!({ "check": { "command": "clippy" } })),
+ settings: Some(json!({ "rust-analyzer": { "cargo": { "features": "all" } } })),
+ ..Default::default()
+ },
+ );
+ let mut ra = server("rust-analyzer");
+ ra.args = vec!["--stdio".into()];
+ ra.initialization_options = Some(toml::Value::Table(toml::toml! { checkOnSave = false }));
+ server_launch_overrides(&mut ra, &s);
+ assert_eq!(ra.args, ["--stdio"], "no args setting keeps the definition's");
+ server_protocol_overrides(&mut ra, &s);
+ assert_eq!(ra.env["RA_LOG"], "info");
+ let init = serde_json::to_value(ra.initialization_options.unwrap()).unwrap();
+ assert_eq!(init, json!({ "checkOnSave": false, "check": { "command": "clippy" } }));
+ assert_eq!(ra.settings, Some(json!({ "rust-analyzer": { "cargo": { "features": "all" } } })));
+}
+
#[test]
fn jdtls_jdk_setting() {
if cfg!(windows) {
diff --git a/crates/ide-tools/src/lib.rs b/crates/ide-tools/src/lib.rs
index bd0e52bad..6ac47b35e 100644
--- a/crates/ide-tools/src/lib.rs
+++ b/crates/ide-tools/src/lib.rs
@@ -72,6 +72,10 @@ pub struct ToolInfo {
pub homepage: Option<String>,
/// Why the executable chosen in settings cannot be used (status is then `Missing`).
pub custom_error: Option<String>,
+ /// A language server's arguments from its language definition.
+ pub default_args: Vec<String>,
+ /// A language server's `initializationOptions` from its language definition, as JSON text.
+ pub default_initialization_options: Option<String>,
}
/// Streamed install progress.
@@ -209,6 +213,8 @@ struct Usage {
command: Option<String>,
kind: Option<ToolKind>,
install_hint: Option<String>,
+ args: Vec<String>,
+ initialization_options: Option<String>,
}
fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
@@ -243,6 +249,14 @@ fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
let languages = map.get(*host).map(|u| u.languages.clone()).unwrap_or_default();
map.entry(plugin.to_string()).or_default().languages = languages;
}
+ // A server's defaults come from the first definition using it.
+ for s in langs.iter().flat_map(|l| &l.language_servers).rev() {
+ if let Some(u) = map.get_mut(&s.name) {
+ u.args = s.args.clone();
+ u.initialization_options =
+ s.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok()).map(|v| v.to_string());
+ }
+ }
map
}
@@ -455,6 +469,8 @@ impl Tools {
install_hint,
homepage: None,
custom_error: None,
+ default_args: u.args.clone(),
+ default_initialization_options: u.initialization_options.clone(),
})
.map(|info| self.apply_custom(info, None));
};
@@ -477,6 +493,8 @@ impl Tools {
install_hint,
homepage: Some(spec.homepage.to_string()),
custom_error: None,
+ default_args: usage.map(|u| u.args.clone()).unwrap_or_default(),
+ default_initialization_options: usage.and_then(|u| u.initialization_options.clone()),
})
.map(|info| self.apply_custom(info, Some(spec)))
}
diff --git a/crates/ide-workspace/src/settings.rs b/crates/ide-workspace/src/settings.rs
index b7afa4b12..f814cb393 100644
--- a/crates/ide-workspace/src/settings.rs
+++ b/crates/ide-workspace/src/settings.rs
@@ -106,20 +106,33 @@ fn json_to_toml(value: &Json) -> IdeResult<toml_edit::Value> {
})
}
-/// Sets (or removes, for `None`) a dotted key in a TOML document.
-fn set_in_document(doc: &mut DocumentMut, segments: &[&str], value: Option<toml_edit::Value>) {
+/// Sets (or removes, for `None`) a dotted key in a TOML document. A new
+/// `map_entry` object becomes a `[languageServers.ruff]` table rather than an
+/// inline table under an explicit `[languageServers]` header.
+fn set_in_document(doc: &mut DocumentMut, segments: &[&str], value: Option<toml_edit::Value>, map_entry: bool) {
let (last, parents) = segments.split_last().expect("non-empty key");
let mut table: &mut dyn TableLike = doc.as_table_mut();
+ let mut in_inline = false;
for seg in parents {
if !table.get(seg).is_some_and(Item::is_table_like) {
if value.is_none() {
return;
}
- table.insert(seg, Item::Table(Table::new()));
+ // Implicit: no `[languageServers]` header above `[languageServers.ruff]`.
+ let mut new = Table::new();
+ new.set_implicit(true);
+ table.insert(seg, Item::Table(new));
}
- table = table.get_mut(seg).and_then(Item::as_table_like_mut).expect("table just ensured");
+ let item = table.get_mut(seg).expect("table just ensured");
+ in_inline |= item.is_inline_table();
+ table = item.as_table_like_mut().expect("table just ensured");
}
match value {
+ Some(toml_edit::Value::InlineTable(t))
+ if map_entry && !in_inline && !matches!(table.get(last), Some(Item::Value(_))) =>
+ {
+ table.insert(last, Item::Table(t.into_table()));
+ }
Some(v) => match table.get_mut(last) {
// Keep the key's decor (comments, spacing) when replacing a value.
Some(Item::Value(existing)) => {
@@ -188,9 +201,19 @@ impl SettingsStore {
if segments.iter().any(|s| s.is_empty()) {
return Err(IdeError::invalid(format!("invalid settings key {key:?}")));
}
- let mut cursor = &defaults_json();
- for seg in &segments {
- cursor = cursor.get(seg).ok_or_else(|| IdeError::invalid(format!("unknown setting {key:?}")))?;
+ let defaults = defaults_json();
+ let mut cursor = &defaults;
+ let mut map_entry = false;
+ for (i, seg) in segments.iter().enumerate() {
+ match cursor.get(seg) {
+ Some(next) => cursor = next,
+ // An entry of a map setting (`languageServers.rust-analyzer`): the merge below validates it.
+ None if cursor.as_object().is_some_and(|m| m.is_empty()) => {
+ map_entry = i + 1 == segments.len();
+ break;
+ }
+ None => return Err(IdeError::invalid(format!("unknown setting {key:?}"))),
+ }
}
let text = match std::fs::read_to_string(&file) {
@@ -202,7 +225,7 @@ impl SettingsStore {
.parse()
.map_err(|e| IdeError::invalid(format!("{} is not valid TOML; fix it first: {e}", file.display())))?;
let new_value = if value.is_null() { None } else { Some(json_to_toml(&value)?) };
- set_in_document(&mut doc, &segments, new_value);
+ set_in_document(&mut doc, &segments, new_value, map_entry);
let new_text = doc.to_string();
// Validate the resulting stack before touching the disk.
@@ -350,6 +373,47 @@ mod tests {
let s =
store.set(SettingsScope::Global, "appearance.statusBarWidgets", json!({"editor.caret": false})).unwrap();
assert_eq!(s.appearance.status_bar_widgets.len(), 1);
+ // One entry of a map setting, set and removed on its own.
+ let s = store
+ .set(
+ SettingsScope::Global,
+ "languageServers.rust-analyzer",
+ json!({"args": ["--log"], "initializationOptions": {"check": {"command": "clippy"}}}),
+ )
+ .unwrap();
+ let ra = &s.language_servers["rust-analyzer"];
+ assert!(ra.enabled);
+ assert_eq!(ra.args.as_deref(), Some(&["--log".to_string()][..]));
+ assert_eq!(ra.initialization_options, Some(json!({"check": {"command": "clippy"}})));
+ assert_eq!(
+ store
+ .set(SettingsScope::Global, "languageServers.rust-analyzer", json!({"enabled": "no"}))
+ .unwrap_err()
+ .kind,
+ ide_core::error::ErrorKind::InvalidInput
+ );
+ let s = store.set(SettingsScope::Global, "languageServers.rust-analyzer", json!(null)).unwrap();
+ assert!(s.language_servers.is_empty());
+ // New parent tables stay implicit: no empty `[languageServers]` header.
+ let fresh = tmp.path().join("fresh");
+ let s = SettingsStore::load(&fresh, None)
+ .set(SettingsScope::Global, "languageServers.ruff.languages", json!(["python"]))
+ .unwrap();
+ assert!(s.language_servers["ruff"].is_custom());
+ let text = std::fs::read_to_string(fresh.join("settings.toml")).unwrap();
+ assert_eq!(text, "[languageServers.ruff]\nlanguages = [\"python\"]\n");
+ // A whole new entry: a table of its own, still under an implicit parent.
+ let added = tmp.path().join("added");
+ let s = SettingsStore::load(&added, None)
+ .set(
+ SettingsScope::Global,
+ "languageServers.ruff",
+ json!({"command": "ruff", "args": ["server"], "languages": ["python"]}),
+ )
+ .unwrap();
+ assert_eq!(s.language_servers["ruff"].command, "ruff");
+ let text = std::fs::read_to_string(added.join("settings.toml")).unwrap();
+ assert_eq!(text, "[languageServers.ruff]\nargs = [\"server\"]\ncommand = \"ruff\"\nlanguages = [\"python\"]\n");
// Project layer is created on demand and wins.
let s = store.set(SettingsScope::Project, "editor.fontSize", json!(12)).unwrap();
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index be5f963e0..4fcbc9e78 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -22,7 +22,7 @@ tauri-plugin-single-instance = "2"
tauri-plugin-updater = "2"
tracing-appender = "0.2"
tauri-specta = { version = "=2.0.0-rc.25", features = ["derive", "typescript"] }
-specta-typescript = "0.0.12"
+specta-typescript.workspace = true
specta.workspace = true
serde.workspace = true
serde_json.workspace = true
diff --git a/src/bindings.ts b/src/bindings.ts
index 2114830d4..f8e6e914f 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -3433,6 +3433,64 @@ export type LanguageInfo_Serialize = {
firstLine?: string | null,
};
+export type LanguageServerSettings = LanguageServerSettings_Serialize | LanguageServerSettings_Deserialize;
+
+export type LanguageServerSettings_Deserialize = {
+ /** `false` keeps the server from starting for any language. */
+ enabled?: boolean,
+ /**
+ * Executable to launch instead of the definition's; required for a server
+ * defined here (one with `languages`).
+ */
+ command?: string,
+ /** Replaces the definition's arguments. */
+ args?: string[] | null,
+ /** Added to the server's environment. */
+ env?: { [key in string]: string },
+ /** Merged over the definition's `initializationOptions` (sent once at startup). */
+ initializationOptions?: unknown | null,
+ /**
+ * Answers the server's `workspace/configuration` requests; changes are pushed
+ * with `workspace/didChangeConfiguration` without a restart.
+ */
+ settings?: unknown | null,
+ /**
+ * Language ids a server defined here serves (`python`); empty for the servers
+ * of the language definitions.
+ */
+ languages?: string[],
+ /** Files marking a workspace root for a server defined here (`pyproject.toml`). */
+ rootMarkers?: string[],
+};
+
+export type LanguageServerSettings_Serialize = {
+ /** `false` keeps the server from starting for any language. */
+ enabled: boolean,
+ /**
+ * Executable to launch instead of the definition's; required for a server
+ * defined here (one with `languages`).
+ */
+ command: string,
+ /** Replaces the definition's arguments. */
+ args?: string[] | null,
+ /** Added to the server's environment. */
+ env: { [key in string]: string },
+ /** Merged over the definition's `initializationOptions` (sent once at startup). */
+ initializationOptions?: unknown | null,
+ /**
+ * Answers the server's `workspace/configuration` requests; changes are pushed
+ * with `workspace/didChangeConfiguration` without a restart.
+ */
+ settings?: unknown | null,
+ /**
+ * Language ids a server defined here serves (`python`); empty for the servers
+ * of the language definitions.
+ */
+ languages: string[],
+ /** Files marking a workspace root for a server defined here (`pyproject.toml`). */
+ rootMarkers: string[],
+};
+
export type LanguagesSettings = {
python?: PythonSettings,
node?: NodeSettings,
@@ -4859,6 +4917,11 @@ export type Settings_Deserialize = {
* command the language definition launches (`elixir-ls`, `codelldb`).
*/
tools?: { [key in string]: ToolSettings },
+ /**
+ * Per language server, by name (`rust-analyzer`): launch and protocol
+ * options on top of the language definition, or a server defined here.
+ */
+ languageServers?: { [key in string]: LanguageServerSettings_Deserialize },
/** Editor › Inspections profiles. */
inspections?: InspectionSettings,
/** Editor › Natural Languages › Spelling. */
@@ -4907,6 +4970,11 @@ export type Settings_Serialize = {
* command the language definition launches (`elixir-ls`, `codelldb`).
*/
tools: { [key in string]: ToolSettings },
+ /**
+ * Per language server, by name (`rust-analyzer`): launch and protocol
+ * options on top of the language definition, or a server defined here.
+ */
+ languageServers: { [key in string]: LanguageServerSettings_Serialize },
/** Editor › Inspections profiles. */
inspections: InspectionSettings,
/** Editor › Natural Languages › Spelling. */
@@ -5406,6 +5474,10 @@ export type ToolInfo = {
homepage: string | null,
/** Why the executable chosen in settings cannot be used (status is then `Missing`). */
customError: string | null,
+ /** A language server's arguments from its language definition. */
+ defaultArgs: string[],
+ /** A language server's `initializationOptions` from its language definition, as JSON text. */
+ defaultInitializationOptions: string | null,
};
export type ToolKind = "languageServer" | "debugger" |
diff --git a/src/features/settings/__tests__/staging.test.ts b/src/features/settings/__tests__/staging.test.ts
index be3668ae0..67542ccd4 100644
--- a/src/features/settings/__tests__/staging.test.ts
+++ b/src/features/settings/__tests__/staging.test.ts
@@ -53,6 +53,33 @@ describe("settings staging", () => {
expect(pendingChanges(s())).toHaveLength(1);
});
+ it("stages entries of map settings and fields inside them", () => {
+ const page = "languages.servers";
+ const s = () => useSettingsDialog.getState();
+ // A field of an entry nobody has set yet; reading the map shows it.
+ stage(page, "global", "languageServers.rust-analyzer.args", ["--log"]);
+ expect(stagedValue(s(), "global", "languageServers")).toEqual({ "rust-analyzer": { args: ["--log"] } });
+ // Cleared again: nothing to write.
+ stage(page, "global", "languageServers.rust-analyzer.args", null);
+ expect(pendingChanges(s())).toEqual([]);
+
+ // A new entry, then an edit inside it: one write of the whole entry.
+ stage(page, "global", "languageServers.ruff", { command: "ruff", languages: ["python"] });
+ stage(page, "global", "languageServers.ruff.args", ["server"]);
+ stage(page, "global", "languageServers.ruff.command", null);
+ expect(stagedValue(s(), "global", "languageServers.ruff.args")).toEqual(["server"]);
+ expect(pendingChanges(s()).map((c) => [c.key, c.value])).toEqual([
+ ["languageServers.ruff", { languages: ["python"], args: ["server"] }],
+ ]);
+
+ // Removing an entry drops the edits staged inside it.
+ stage(page, "global", "languageServers.gopls.env", { GOFLAGS: "-mod=mod" });
+ stage(page, "global", "languageServers.gopls", null);
+ stage(page, "global", "languageServers.ruff", null);
+ expect(pendingChanges(s())).toEqual([]);
+ expect(stagedValue(s(), "global", "languageServers")).toEqual({});
+ });
+
it("opens Settings for New Projects on request", () => {
expect(useSettingsDialog.getState().newProjects).toBe(false);
openSettings("languages.java", { newProjects: true });
diff --git a/src/features/settings/components/context.ts b/src/features/settings/components/context.ts
index 96c0be058..9e762f663 100644
--- a/src/features/settings/components/context.ts
+++ b/src/features/settings/components/context.ts
@@ -1,5 +1,6 @@
/** Page context for the form components: which page / scope they edit and the search query. */
-import { createContext, useCallback, useContext } from "react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import type { SettingsForm } from "@/workbench/contributions";
import { stage, stagedValue, useSettingsDialog, type Scope } from "../model/staging";
import { labelMatches } from "../model/pages";
@@ -23,6 +24,25 @@ export function useSetting<T>(key: string, scopeOverride?: Scope): [T, (value: T
return [value, set];
}
+/** `stagedValue` for components; recomputed only when the base or the staged edits change. */
+export function useStagedValue(scope: Scope, key: string): unknown {
+ const base = useSettingsDialog((s) => (scope === "global" ? s.globalBase : s.base));
+ const staged = useSettingsDialog((s) => s.staged);
+ return useMemo(() => stagedValue({ base, globalBase: base, staged }, scope, key), [base, staged, scope, key]);
+}
+
+/** The form contributed pages edit through (`useSettingsForm`). */
+export function useSettingsFormFor(pageId: string, scope: Scope): SettingsForm {
+ return useMemo(
+ () => ({
+ scope,
+ useValue: (key: string) => useStagedValue(scope, key),
+ set: (key: string, value: unknown) => stage(pageId, scope, key, value),
+ }),
+ [pageId, scope],
+ );
+}
+
export function useSearchQuery(): string {
return useSettingsDialog((s) => s.query);
}
diff --git a/src/features/settings/dialog/SettingsDialog.tsx b/src/features/settings/dialog/SettingsDialog.tsx
index 9b562d546..0fcd87345 100644
--- a/src/features/settings/dialog/SettingsDialog.tsx
+++ b/src/features/settings/dialog/SettingsDialog.tsx
@@ -9,7 +9,7 @@
import { useMemo, useRef, useState } from "react";
import clsx from "clsx";
import { useProject } from "@/platform/project";
-import { useSettingsPages, type SettingsPageContribution } from "@/workbench/contributions";
+import { SettingsFormContext, useSettingsPages, type SettingsPageContribution } from "@/workbench/contributions";
import {
Dialog,
DialogButtons,
@@ -22,7 +22,7 @@ import {
type TreeHandle,
T,
} from "@/ui";
-import { PageContext } from "../components/context";
+import { PageContext, useSettingsFormFor } from "../components/context";
import { SearchLabel } from "../components/Form";
import { breadcrumb, buildPageTree, filterPageTree, flatten, groupKey, type PageNode } from "../model/pages";
import {
@@ -102,60 +102,63 @@ function PageHost({
const hasProject = useProject((s) => !!s.project);
const newProjects = useSettingsDialog((s) => s.newProjects);
const spec = page ? builtinSpec(page.id) : undefined;
- const projectScope = !!spec?.projectScope && hasProject && !newProjects;
+ const projectScope = !!(spec?.projectScope ?? page?.projectScope) && hasProject && !newProjects;
const scopeKey = spec?.scopeGroup ?? pageId;
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? spec?.defaultScope;
const scope: Scope = projectScope && chosen === "project" ? "project" : "global";
// Where a project value is the norm, say what the global one is for.
const globalNote = newProjects || (projectScope && scope === "global" && spec?.defaultScope === "project");
const ctx = useMemo(() => ({ pageId, scope }), [pageId, scope]);
+ const form = useSettingsFormFor(pageId, scope);
if (!node) return <EmptyState title="Nothing found" icon="search" />;
const Body = page?.component;
return (
<PageContext.Provider value={ctx}>
- <div className={styles.pageHeader}>
- <div className={styles.crumbs} aria-label={tx("Breadcrumb")}>
- {crumbs.map((c, i) => (
- <span key={i} className={styles.crumb}>
- {i > 0 && <Icon name="chevron-right" size={12} className={styles.crumbSep} />}
- <span>
- <T>{c}</T>
+ <SettingsFormContext.Provider value={form}>
+ <div className={styles.pageHeader}>
+ <div className={styles.crumbs} aria-label={tx("Breadcrumb")}>
+ {crumbs.map((c, i) => (
+ <span key={i} className={styles.crumb}>
+ {i > 0 && <Icon name="chevron-right" size={12} className={styles.crumbSep} />}
+ <span>
+ <T>{c}</T>
+ </span>
</span>
- </span>
- ))}
+ ))}
+ </div>
+ {dirty && (
+ <button type="button" className={styles.reset} onClick={onReset}>
+ <T>Reset</T>
+ </button>
+ )}
+ {projectScope && !spec?.ownScopeSwitch && <ScopeSwitch pageId={scopeKey} scope={scope} />}
+ <span className={styles.history}>
+ <IconButton icon="arrow-left" title="Back" size="small" disabled={!history.back} onClick={history.back} />
+ <IconButton
+ icon="arrow-right"
+ title="Forward"
+ size="small"
+ disabled={!history.forward}
+ onClick={history.forward}
+ />
+ </span>
</div>
- {dirty && (
- <button type="button" className={styles.reset} onClick={onReset}>
- <T>Reset</T>
- </button>
+ {scope === "project" && (
+ <div className={styles.scopeNote}>
+ <Icon name="info" size={14} />
+ <T>Saved to .openidea/settings.toml in this project; overrides the global value.</T>
+ </div>
)}
- {projectScope && !spec?.ownScopeSwitch && <ScopeSwitch pageId={scopeKey} scope={scope} />}
- <span className={styles.history}>
- <IconButton icon="arrow-left" title="Back" size="small" disabled={!history.back} onClick={history.back} />
- <IconButton
- icon="arrow-right"
- title="Forward"
- size="small"
- disabled={!history.forward}
- onClick={history.forward}
- />
- </span>
- </div>
- {scope === "project" && (
- <div className={styles.scopeNote}>
- <Icon name="info" size={14} />
- <T>Saved to .openidea/settings.toml in this project; overrides the global value.</T>
- </div>
- )}
- {globalNote && (
- <div className={styles.scopeNote}>
- <Icon name="info" size={14} />
- <T>Saved to the global settings: used by new projects and by projects without their own value.</T>
+ {globalNote && (
+ <div className={styles.scopeNote}>
+ <Icon name="info" size={14} />
+ <T>Saved to the global settings: used by new projects and by projects without their own value.</T>
+ </div>
+ )}
+ <div className={styles.pageBody}>
+ <PageErrorBoundary pageId={pageId}>{Body ? <Body /> : <GroupPage node={node} />}</PageErrorBoundary>
</div>
- )}
- <div className={styles.pageBody}>
- <PageErrorBoundary pageId={pageId}>{Body ? <Body /> : <GroupPage node={node} />}</PageErrorBoundary>
- </div>
+ </SettingsFormContext.Provider>
</PageContext.Provider>
);
}
diff --git a/src/features/settings/model/schema.ts b/src/features/settings/model/schema.ts
index 34505b45a..af2904a17 100644
--- a/src/features/settings/model/schema.ts
+++ b/src/features/settings/model/schema.ts
@@ -5,12 +5,8 @@
* back to the default (mirrors `ide-core::settings` defaults).
*/
import { DEFAULT_IGNORED_NAMES } from "@/platform/ignoredNames";
-import {
- validateFileTypeOverrides,
- validateFileTypes,
- type FileTypeAssociations,
-} from "@/platform/fileTypes";
-import type { Settings } from "@/platform/ipc";
+import { validateFileTypeOverrides, validateFileTypes, type FileTypeAssociations } from "@/platform/fileTypes";
+import type { LanguageServerSettings, Settings } from "@/platform/ipc";
import {
DEFAULT_LANGUAGES,
DEFAULT_PROJECT_STRUCTURE,
@@ -86,8 +82,15 @@ export interface ValidSettings extends WorkflowSettings {
inspections: InspectionSettingsValid;
/** Editor › Natural Languages › Spelling. */
spelling: SpellingValid;
+ /** Executables chosen for language servers / debug adapters, by command. */
+ tools: Record<string, { path: string }>;
+ /** Settings › Language Servers, by server name (as the backend sends them). */
+ languageServers: Record<string, LanguageServerEntry>;
}
+/** One `languageServers.<name>` entry; every field optional, like in settings.toml. */
+export type LanguageServerEntry = Partial<LanguageServerSettings>;
+
export interface SpellingValid {
ideWords: string[];
projectWords: string[];
@@ -144,6 +147,8 @@ export const DEFAULT_SETTINGS: ValidSettings = {
projectStructure: DEFAULT_PROJECT_STRUCTURE,
inspections: DEFAULT_INSPECTIONS,
spelling: { ideWords: [], projectWords: [], customDictionaries: [] },
+ tools: {},
+ languageServers: {},
...DEFAULT_WORKFLOW,
};
@@ -244,6 +249,15 @@ export function validateSettings(raw: Settings | unknown): ValidSettings {
projectStructure: validateProjectStructure(root.projectStructure),
inspections: validateInspections(root.inspections),
spelling: validateSpelling(root.spelling),
+ tools: Object.fromEntries(
+ Object.entries(obj(root.tools)).flatMap(([cmd, t]) => {
+ const path = obj(t).path;
+ return typeof path === "string" ? [[cmd, { path }]] : [];
+ }),
+ ),
+ languageServers: Object.fromEntries(
+ Object.entries(obj(root.languageServers)).map(([name, ls]) => [name, obj(ls) as LanguageServerEntry]),
+ ),
...validateWorkflow(root),
};
}
@@ -265,6 +279,16 @@ export function setAt<T>(source: T, key: string, value: unknown): T {
return { ...base, [head!]: rest.length ? setAt(base[head!], rest.join("."), value) : value } as T;
}
+/** Like `setAt`, but `null` / `undefined` removes the key (as a settings write of `null` does). */
+export function putAt<T>(source: T, key: string, value: unknown): T {
+ const [head, ...rest] = key.split(".");
+ const base = { ...obj(source) };
+ if (rest.length) base[head!] = putAt(base[head!], rest.join("."), value);
+ else if (value == null) delete base[head!];
+ else base[head!] = value;
+ return base as T;
+}
+
export function deepEqual(a: unknown, b: unknown): boolean {
if (a === b) return true;
if (typeof a !== typeof b || !a || !b || typeof a !== "object") return false;
diff --git a/src/features/settings/model/staging.ts b/src/features/settings/model/staging.ts
index 1591da3c5..891678d42 100644
--- a/src/features/settings/model/staging.ts
+++ b/src/features/settings/model/staging.ts
@@ -6,7 +6,7 @@
import { create } from "zustand";
import { call, commands, isTauri, type Settings } from "@/platform/ipc";
import { loadSettings, useProject } from "@/platform/project";
-import { deepEqual, getAt, setAt, validateSettings, type ValidSettings } from "./schema";
+import { deepEqual, getAt, putAt, setAt, validateSettings, type ValidSettings } from "./schema";
export type Scope = "global" | "project";
@@ -119,19 +119,48 @@ export function setPageScope(pageId: string, scope: Scope) {
useSettingsDialog.setState((s) => ({ scopes: { ...s.scopes, [pageId]: scope } }));
}
-/** Current value of `key` as the page shows it: staged edit, else the effective value. */
+const isInside = (key: string, parent: string) => key.startsWith(`${parent}.`);
+
+/**
+ * Current value of `key` as the page shows it: staged edit, else the effective
+ * value. Edits staged for a parent (a whole map entry) or inside `key` (one
+ * field of it) show through too.
+ */
export function stagedValue(s: Bases & Pick<SettingsDialogState, "staged">, scope: Scope, key: string): unknown {
const hit = s.staged[stageKey(scope, key)];
- return hit ? hit.value : getAt(baseFor(s, scope), key);
+ if (hit) return hit.value;
+ const related = Object.values(s.staged).filter(
+ (c) => c.scope === scope && (isInside(key, c.key) || isInside(c.key, key)),
+ );
+ let value = getAt(baseFor(s, scope), key);
+ for (const c of related.sort((a, b) => a.key.length - b.key.length)) {
+ value = isInside(key, c.key)
+ ? (getAt(c.value, key.slice(c.key.length + 1)) ?? undefined)
+ : putAt(value, c.key.slice(key.length + 1), c.value);
+ }
+ return value;
}
+/**
+ * Stages `value` for `key`; `null` removes the key on Apply. An edit inside an
+ * entry staged as a whole (a map entry just added) goes into that entry; a new
+ * value for `key` drops the edits staged inside it.
+ */
export function stage(page: string, scope: Scope, key: string, value: unknown) {
useSettingsDialog.setState((s) => {
const staged = { ...s.staged };
+ const parent = Object.values(staged).find((c) => c.scope === scope && isInside(key, c.key));
+ if (parent) {
+ const merged = putAt(parent.value, key.slice(parent.key.length + 1), value);
+ staged[stageKey(scope, parent.key)] = { ...parent, value: merged };
+ return { staged, error: null };
+ }
+ for (const [id, c] of Object.entries(staged)) if (c.scope === scope && isInside(c.key, key)) delete staged[id];
const id = stageKey(scope, key);
+ const next = value === undefined ? null : value;
// Back to the scope's current value: nothing to write.
- if (deepEqual(value, getAt(baseFor(s, scope), key))) delete staged[id];
- else staged[id] = { scope, key, value, page };
+ if (deepEqual(next ?? undefined, getAt(baseFor(s, scope), key))) delete staged[id];
+ else staged[id] = { scope, key, value: next, page };
return { staged, error: null };
});
}
@@ -147,7 +176,7 @@ export function resetPage(page: string) {
/** Writes to perform, global layer first so a project value still wins afterwards. */
export function pendingChanges(s: Bases & Pick<SettingsDialogState, "staged">): StagedChange[] {
return Object.values(s.staged)
- .filter((c) => !deepEqual(c.value, getAt(baseFor(s, c.scope), c.key)))
+ .filter((c) => !deepEqual(c.value ?? undefined, getAt(baseFor(s, c.scope), c.key)))
.sort((a, b) => (a.scope === b.scope ? a.key.localeCompare(b.key) : a.scope === "global" ? -1 : 1));
}
@@ -217,7 +246,7 @@ export async function applySettings(deps?: PersistDeps): Promise<boolean> {
globalBase: useProject.getState().project
? changes
.filter((c) => c.scope === "global" && done.has(stageKey(c.scope, c.key)))
- .reduce((g, c) => setAt(g, c.key, c.value), st.globalBase)
+ .reduce((g, c) => putAt(g, c.key, c.value), st.globalBase)
: base,
staged: Object.fromEntries(Object.entries(st.staged).filter(([k]) => !done.has(k))),
}));
diff --git a/src/features/tools/LanguageServersPage.module.css b/src/features/tools/LanguageServersPage.module.css
index d5f3d8968..1c1eff93e 100644
--- a/src/features/tools/LanguageServersPage.module.css
+++ b/src/features/tools/LanguageServersPage.module.css
@@ -25,7 +25,7 @@
display: flex;
flex: none;
flex-direction: column;
- width: 300px;
+ width: 264px;
min-height: 0;
border-right: 1px solid var(--border);
}
@@ -39,6 +39,13 @@
flex: 1;
min-width: 0;
}
+.toolbarSep {
+ flex: none;
+ width: 1px;
+ height: 16px;
+ margin: 0 2px;
+ background: var(--border);
+}
.segmented {
display: flex;
height: var(--h-control-small);
@@ -111,6 +118,10 @@
outline: none;
background: var(--bg-hover);
}
+.rowOff .rowName,
+.rowOff .rowLanguages {
+ color: var(--fg-muted);
+}
.rowName {
flex: none;
max-width: 60%;
@@ -162,6 +173,7 @@
gap: 12px;
}
.headerText {
+ flex: 1;
min-width: 0;
}
.title {
@@ -178,60 +190,36 @@
}
.actions {
display: flex;
+ flex: none;
align-items: center;
gap: 4px;
}
-.fields {
- display: grid;
- grid-template-columns: max-content minmax(0, 1fr);
- column-gap: 16px;
- row-gap: 8px;
- align-items: baseline;
- margin-top: 4px;
-}
-.field {
- display: contents;
-}
-.fieldLabel {
- color: var(--fg-secondary);
-}
-.fieldValue {
- min-width: 0;
- color: var(--fg);
-}
-code.fieldValue {
- font-family: var(--font-mono);
+.linkButton {
+ padding: 0;
+ border: 0;
+ background: none;
+ color: var(--link);
+ font: inherit;
font-size: var(--fs-small);
+ cursor: pointer;
}
-.breakAll {
- overflow-wrap: anywhere;
-}
-.version {
- font-variant-numeric: tabular-nums;
-}
-.pathRow {
- display: flex;
- align-items: center;
- gap: 4px;
+.linkButton:hover {
+ color: var(--link-hover);
+ text-decoration: underline;
}
-.pathInput {
- flex: 1;
- min-width: 0;
+.linkButton:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
}
.fieldHint {
- margin-top: 2px;
+ margin-top: -4px;
color: var(--fg-muted);
font-size: var(--fs-small);
}
-.fieldError,
.error {
color: var(--danger);
overflow-wrap: anywhere;
}
-.fieldError {
- margin-top: 2px;
- font-size: var(--fs-small);
-}
.notice {
padding: 6px 8px;
border-radius: var(--radius-small);
@@ -265,7 +253,7 @@ code.fieldValue {
font-size: var(--fs-small);
}
.log {
- margin: 0;
+ margin: 4px 0 0;
padding: 6px 8px;
max-height: 240px;
overflow: auto;
diff --git a/src/features/tools/LanguageServersPage.tsx b/src/features/tools/LanguageServersPage.tsx
index 549edcc66..b5407495f 100644
--- a/src/features/tools/LanguageServersPage.tsx
+++ b/src/features/tools/LanguageServersPage.tsx
@@ -1,18 +1,23 @@
/**
* Settings › Languages & Frameworks › Language Servers, laid out like the
- * Plugins page: language servers and debug adapters in a list on the left,
- * the selected tool's location, custom path and install actions on the right.
+ * Plugins page: language servers and debug adapters in a list on the left
+ * (+ adds a server of one's own, − removes it), the selected tool's install
+ * actions and settings on the right. Settings are staged in the dialog and
+ * written on Apply / OK; installs run right away.
*/
-import { useEffect, useId, useMemo, useState, type KeyboardEvent } from "react";
+import { useEffect, useMemo, useState, type KeyboardEvent } from "react";
import clsx from "clsx";
import type { ToolInfo } from "@/bindings";
-import { Badge, Button, EmptyState, IconButton, Input, ProgressBar, SearchField, Spinner, T } from "@/ui";
-import { toolsBackend } from "./backend";
+import { Badge, Button, EmptyState, IconButton, ProgressBar, SearchField, Spinner, T } from "@/ui";
+import { onIdeEvent } from "@/platform/ipc";
+import { useProject } from "@/platform/project";
+import { useSettingsForm } from "@/workbench/contributions";
+import { languageNames, NewServerDialog, ServerSettings, ToolSettings, useLanguageChoices } from "./ServerSettings";
+import { serverKey, type ServerEntry } from "./serverConfig";
import {
cancelInstall,
installTool,
refreshTools,
- setCustomPath,
STATUS_LABEL,
uninstallTool,
useTools,
@@ -46,6 +51,29 @@ export function filterTools(tools: readonly ToolInfo[], query: string, filter: F
});
}
+/** A server added in this dialog, listed before Apply checks its executable. */
+function pendingTool(name: string, entry: ServerEntry, languages: string[]): ToolInfo {
+ return {
+ name,
+ displayName: name,
+ kind: "languageServer",
+ command: entry.command ?? "",
+ languages,
+ status: "missing",
+ path: null,
+ version: null,
+ installMethod: null,
+ canInstall: false,
+ unavailableReason: null,
+ canUninstall: false,
+ installHint: null,
+ homepage: null,
+ customError: null,
+ defaultArgs: [],
+ defaultInitializationOptions: null,
+ };
+}
+
function JobRow({ name, job }: { name: string; job: InstallJob }) {
return (
<div className={styles.job}>
@@ -62,140 +90,117 @@ function JobRow({ name, job }: { name: string; job: InstallJob }) {
);
}
-function ToolRow({ tool, selected, onSelect }: { tool: ToolInfo; selected: boolean; onSelect: () => void }) {
+function ToolRow({
+ tool,
+ selected,
+ off,
+ pending,
+ onSelect,
+}: {
+ tool: ToolInfo;
+ selected: boolean;
+ off: boolean;
+ pending: boolean;
+ onSelect: () => void;
+}) {
return (
<li className={clsx(styles.row, selected && styles.rowSelected)}>
<button
type="button"
- className={styles.rowMain}
+ className={clsx(styles.rowMain, off && styles.rowOff)}
aria-current={selected || undefined}
data-tool={tool.name}
title={`${tool.displayName} — ${tool.languages.join(", ")}`}
onClick={onSelect}
>
- <Badge dot tone={STATUS_TONE[tool.status]}>
- {STATUS_LABEL[tool.status]}
+ <Badge dot tone={pending ? "accent" : STATUS_TONE[tool.status]}>
+ {pending ? tx("New") : STATUS_LABEL[tool.status]}
</Badge>
<span className={styles.rowName}>{tool.displayName}</span>
+ {pending && (
+ <span className={styles.kindTag}>
+ <T>New</T>
+ </span>
+ )}
{tool.kind !== "languageServer" && (
<span className={styles.kindTag}>
<T>{KIND_LABEL[tool.kind]}</T>
</span>
)}
+ {off && (
+ <span className={styles.kindTag}>
+ <T>Disabled</T>
+ </span>
+ )}
<span className={styles.rowLanguages}>{tool.languages.join(", ")}</span>
</button>
</li>
);
}
-/** "Path" field: an executable to launch instead of the detected one, saved when committed. */
-function CustomPath({ tool }: { tool: ToolInfo }) {
- const id = useId();
- const saved = tool.status === "custom" || tool.customError ? (tool.path ?? "") : "";
- const [draft, setDraft] = useState<string | null>(null);
- const value = draft ?? (tool.status === "custom" ? saved : "");
- const commit = async (next: string) => {
- setDraft(null);
- if (next.trim() !== saved) await setCustomPath(tool.command, next);
- };
- return (
- <div className={styles.field}>
- <label className={styles.fieldLabel} htmlFor={id}>
- <T>Path</T>
- </label>
- <div className={styles.fieldValue}>
- <span className={styles.pathRow}>
- <Input
- id={id}
- mono
- className={styles.pathInput}
- value={value}
- invalid={!!tool.customError}
- placeholder={tool.status !== "custom" && tool.path ? tool.path : "Auto-detect"}
- onChange={(e) => setDraft(e.target.value)}
- onBlur={() => draft !== null && void commit(draft)}
- onKeyDown={(e: KeyboardEvent<HTMLInputElement>) => {
- if (e.key === "Enter") void commit(e.currentTarget.value);
- if (e.key === "Escape" && draft !== null) {
- e.stopPropagation();
- setDraft(null);
- }
- }}
- />
- <IconButton
- icon="folder-open"
- size="small"
- title="Browse…"
- onClick={async () => {
- const picked = await toolsBackend().chooseExecutable(`Select ${tool.command}`, value || undefined);
- if (picked) await commit(picked);
- }}
- />
- {tool.status === "custom" && (
- <IconButton icon="close" size="small" title="Use auto-detected" onClick={() => void commit("")} />
- )}
- </span>
- {tool.customError ? (
- <div className={styles.fieldError} role="alert">
- {tool.customError}
- </div>
- ) : (
- <div className={styles.fieldHint}>
- <T>Leave empty to use the IDE-installed copy, else the one on PATH.</T>
- </div>
- )}
- </div>
- </div>
- );
-}
-
-function Details({ tool }: { tool: ToolInfo }) {
+function Details({ tool, pending }: { tool: ToolInfo; pending: boolean }) {
const job = useTools((s) => s.jobs[tool.name]);
const last = useTools((s) => s.logs[tool.name]);
const [logOpen, setLogOpen] = useState(false);
const log = job?.lines ?? last?.lines ?? [];
const lastError = !job && last?.error !== "Cancelled" ? last?.error : null;
const busy = !!job;
- const manualHint = !tool.canInstall && tool.status === "missing";
+ // Servers and adapters show the install hint next to their executable.
+ const manualHint =
+ !pending &&
+ !tool.canInstall &&
+ tool.status === "missing" &&
+ (tool.unavailableReason ?? (tool.kind === "plugin" ? tool.installHint : null));
return (
<div className={styles.details} aria-label={`${tool.displayName} details`}>
<div className={styles.header}>
<div className={styles.headerText}>
<div className={styles.title}>
<span>{tool.displayName}</span>
- <Badge tone={STATUS_TONE[tool.status]}>{STATUS_LABEL[tool.status]}</Badge>
+ {pending ? (
+ <Badge tone="accent">
+ <T>New</T>
+ </Badge>
+ ) : (
+ <Badge tone={STATUS_TONE[tool.status]}>{STATUS_LABEL[tool.status]}</Badge>
+ )}
</div>
<div className={styles.subtitle}>
<T>{KIND_LABEL[tool.kind]}</T>
- {tool.languages.length > 0 && <> · {tool.languages.join(", ")}</>}
+ {tool.version && <> · {tool.version}</>}
+ {tool.homepage && (
+ <>
+ {" · "}
+ <a href={tool.homepage} target="_blank" rel="noreferrer">
+ <T>Homepage</T>
+ </a>
+ </>
+ )}
</div>
</div>
- </div>
-
- <div className={styles.actions}>
- {tool.canInstall && (
- <Button
- size="small"
- variant={tool.status === "missing" ? "primary" : "secondary"}
- disabled={busy}
- onClick={() => void installTool(tool.name)}
- aria-label={
- tool.status === "installed" ? tx`Reinstall ${tool.displayName}` : tx`Install ${tool.displayName}`
- }
- >
- {tool.status === "installed" ? "Reinstall" : "Install"}
- </Button>
- )}
- {tool.canUninstall && (
- <Button size="small" variant="ghost" disabled={busy} onClick={() => void uninstallTool(tool.name)}>
- <T>Uninstall</T>
- </Button>
- )}
- {log.length > 0 && (
- <Button size="small" variant="ghost" aria-expanded={logOpen} onClick={() => setLogOpen(!logOpen)}>
- {logOpen ? "Hide install log" : "Show install log"}
- </Button>
- )}
+ <div className={styles.actions}>
+ {tool.canInstall && (
+ <Button
+ size="small"
+ variant={tool.status === "missing" ? "primary" : "secondary"}
+ disabled={busy}
+ title={
+ tool.installMethod ? tx`Installs into the IDE's own tools folder via ${tool.installMethod}` : undefined
+ }
+ onClick={() => void installTool(tool.name)}
+ aria-label={
+ tool.status === "installed" ? tx`Reinstall ${tool.displayName}` : tx`Install ${tool.displayName}`
+ }
+ >
+ {tool.status === "installed" ? "Reinstall" : "Install"}
+ </Button>
+ )}
+ {tool.canUninstall && (
+ <Button size="small" variant="ghost" disabled={busy} onClick={() => void uninstallTool(tool.name)}>
+ <T>Uninstall</T>
+ </Button>
+ )}
+ </div>
</div>
{job && <JobRow name={tool.displayName} job={job} />}
{lastError && (
@@ -205,58 +210,31 @@ function Details({ tool }: { tool: ToolInfo }) {
)}
{manualHint && (
<div className={styles.notice} role="note">
- {tool.unavailableReason ?? tool.installHint ?? "Install it manually and put it on PATH."}
+ {manualHint}
</div>
)}
- {tool.canInstall && tool.status === "missing" && tool.unavailableReason === null && tool.installMethod && (
- <div className={styles.fieldHint}>
- <T>Installs into the IDE&apos;s own tools folder via</T> {tool.installMethod}.
+ {log.length > 0 && (
+ <div>
+ <button
+ type="button"
+ className={styles.linkButton}
+ aria-expanded={logOpen}
+ onClick={() => setLogOpen(!logOpen)}
+ >
+ {logOpen ? tx("Hide install log") : tx("Show install log")}
+ </button>
+ {logOpen && (
+ <pre className={styles.log} aria-label={`${tool.displayName} install log`}>
+ {log.join("\n")}
+ </pre>
+ )}
</div>
)}
- <div className={styles.fields}>
- <div className={styles.field}>
- <span className={styles.fieldLabel}>
- <T>Command</T>
- </span>
- <code className={styles.fieldValue}>{tool.command}</code>
- </div>
- {tool.kind !== "plugin" && <CustomPath key={`${tool.name}:${tool.path ?? ""}`} tool={tool} />}
- {tool.status !== "custom" && (
- <div className={styles.field}>
- <span className={styles.fieldLabel}>
- <T>Location</T>
- </span>
- <code className={clsx(styles.fieldValue, styles.breakAll)}>{tool.path ?? "—"}</code>
- </div>
- )}
- <div className={styles.field}>
- <span className={styles.fieldLabel}>
- <T>Version</T>
- </span>
- <span className={clsx(styles.fieldValue, styles.version)}>{tool.version ?? "—"}</span>
- </div>
- {tool.homepage && (
- <div className={styles.field}>
- <span className={styles.fieldLabel}>
- <T>Homepage</T>
- </span>
- <a
- className={clsx(styles.fieldValue, styles.breakAll)}
- href={tool.homepage}
- target="_blank"
- rel="noreferrer"
- >
- {tool.homepage}
- </a>
- </div>
- )}
- </div>
-
- {logOpen && log.length > 0 && (
- <pre className={styles.log} aria-label={`${tool.displayName} install log`}>
- {log.join("\n")}
- </pre>
+ {tool.kind === "languageServer" ? (
+ <ServerSettings tool={tool} pending={pending} />
+ ) : (
+ tool.kind === "debugger" && <ToolSettings tool={tool} />
)}
</div>
);
@@ -264,20 +242,44 @@ function Details({ tool }: { tool: ToolInfo }) {
export function LanguageServersPage() {
const { tools, loaded, loading, error } = useTools();
+ const form = useSettingsForm();
const [query, setQuery] = useState("");
const [filter, setFilter] = useState<Filter>("all");
const [selectedName, setSelectedName] = useState<string | null>(null);
+ const [adding, setAdding] = useState(false);
+ const known = useLanguageChoices();
+ const staged = form.useValue("languageServers") as Record<string, ServerEntry> | undefined;
+ const servers = useMemo(() => staged ?? {}, [staged]);
+ const applied = useProject((s) => s.settings?.languageServers);
useEffect(() => {
void refreshTools();
+ // Applied paths and servers change what is found and listed.
+ return onIdeEvent("settingsChanged", (e) => {
+ if (!e.key || /^(tools|languageServers)(\.|$)/.test(e.key)) void refreshTools();
+ });
}, []);
- const shown = useMemo(() => filterTools(tools, query, filter), [tools, query, filter]);
+ // The backend's list, minus servers removed here and plus servers added here (until Apply).
+ const { all, pending } = useMemo(() => {
+ const isCustom = (e: ServerEntry | undefined) => (e?.languages?.length ?? 0) > 0;
+ const list = tools.filter((t) => !isCustom(applied?.[t.name]) || isCustom(servers[t.name]));
+ const added = new Set<string>();
+ for (const [name, entry] of Object.entries(servers)) {
+ if (!isCustom(entry) || list.some((t) => t.name === name)) continue;
+ list.push(pendingTool(name, entry, languageNames(entry.languages ?? [], known)));
+ added.add(name);
+ }
+ return { all: list, pending: added };
+ }, [tools, servers, applied, known]);
+
+ const shown = useMemo(() => filterTools(all, query, filter), [all, query, filter]);
const ready = shown.filter((t) => t.status !== "missing");
const missing = shown.filter((t) => t.status === "missing");
const ordered = [...ready, ...missing];
const selected = ordered.find((t) => t.name === selectedName) ?? ordered[0] ?? null;
- const missingCount = tools.filter((t) => t.status === "missing").length;
+ const missingCount = all.filter((t) => t.status === "missing").length;
+ const removable = !!selected && (servers[selected.name]?.languages?.length ?? 0) > 0;
const onListKey = (e: KeyboardEvent<HTMLUListElement>) => {
if (e.key !== "ArrowDown" && e.key !== "ArrowUp") return;
@@ -296,7 +298,14 @@ export function LanguageServersPage() {
<T>{title}</T> <span className={styles.groupCount}>{list.length}</span>
</li>
{list.map((t) => (
- <ToolRow key={t.name} tool={t} selected={t === selected} onSelect={() => setSelectedName(t.name)} />
+ <ToolRow
+ key={t.name}
+ tool={t}
+ selected={t === selected}
+ off={servers[t.name]?.enabled === false}
+ pending={pending.has(t.name)}
+ onSelect={() => setSelectedName(t.name)}
+ />
))}
</>
);
@@ -315,13 +324,15 @@ export function LanguageServersPage() {
<div className={styles.body}>
<div className={styles.side}>
<div className={styles.toolbar}>
- <SearchField
- className={styles.search}
- value={query}
- onChange={setQuery}
- placeholder="Filter by tool or language"
- aria-label="Filter language servers"
+ <IconButton icon="plus" size="small" title="Add Language Server…" onClick={() => setAdding(true)} />
+ <IconButton
+ icon="minus"
+ size="small"
+ title="Remove Language Server"
+ disabled={!removable}
+ onClick={() => selected && form.set(serverKey(selected.name), null)}
/>
+ <span className={styles.toolbarSep} aria-hidden />
{loading ? (
<Spinner size={14} label="Checking tools" />
) : (
@@ -332,6 +343,13 @@ export function LanguageServersPage() {
onClick={() => void refreshTools()}
/>
)}
+ <SearchField
+ className={styles.search}
+ value={query}
+ onChange={setQuery}
+ placeholder="Filter by tool or language"
+ aria-label="Filter language servers"
+ />
</div>
<div className={styles.segmented} role="radiogroup" aria-label="Show">
{(["all", "missing", "installed"] as const).map((f) => (
@@ -343,7 +361,7 @@ export function LanguageServersPage() {
className={clsx(styles.segment, filter === f && styles.segmentOn)}
onClick={() => setFilter(f)}
>
- {f === "all" ? "All" : f === "missing" ? `Missing (${missingCount})` : "Available"}
+ {f === "all" ? tx("All") : f === "missing" ? tx`Missing (${missingCount})` : tx("Available")}
</button>
))}
</div>
@@ -363,11 +381,23 @@ export function LanguageServersPage() {
</ul>
</div>
{selected ? (
- <Details key={selected.name} tool={selected} />
+ <Details key={selected.name} tool={selected} pending={pending.has(selected.name)} />
) : (
<EmptyState className={styles.detailsEmpty} title={loaded ? "No tool selected" : "Loading…"} />
)}
</div>
+ {adding && (
+ <NewServerDialog
+ existing={all.map((t) => t.name)}
+ onClose={() => setAdding(false)}
+ onAdded={(name) => {
+ setAdding(false);
+ setFilter("all");
+ setQuery("");
+ setSelectedName(name);
+ }}
+ />
+ )}
</div>
);
}
diff --git a/src/features/tools/ServerSettings.module.css b/src/features/tools/ServerSettings.module.css
new file mode 100644
index 000000000..75c563cee
--- /dev/null
+++ b/src/features/tools/ServerSettings.module.css
@@ -0,0 +1,188 @@
+.form {
+ display: flex;
+ flex-direction: column;
+ gap: 16px;
+ min-width: 0;
+}
+
+/* IDEA titled separator: "Startup ─────────". */
+.section {
+ min-width: 0;
+}
+.sectionTitle {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ height: 22px;
+ margin-bottom: 4px;
+ color: var(--fg-strong);
+}
+.sectionRule {
+ flex: 1;
+ height: 1px;
+ background: var(--border);
+}
+.sectionToggle {
+ width: 100%;
+ padding: 0;
+ border: 0;
+ background: none;
+ font: inherit;
+ text-align: left;
+ cursor: pointer;
+}
+.sectionToggle:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
+}
+.sectionBody {
+ display: flex;
+ flex-direction: column;
+ gap: 10px;
+ padding: 4px 0 0 12px;
+}
+
+/* Label above a full-width control: the details pane is narrow. */
+.row {
+ display: flex;
+ flex-direction: column;
+ gap: 4px;
+ min-width: 0;
+}
+.label {
+ color: var(--fg);
+}
+.label::after {
+ content: ":";
+}
+.control {
+ display: flex;
+ align-items: flex-start;
+ gap: 4px;
+ min-width: 0;
+}
+.hint {
+ color: var(--fg-subtle);
+ font-size: var(--fs-small);
+ line-height: 1.4;
+ overflow-wrap: anywhere;
+}
+.note {
+ color: var(--fg-subtle);
+ font-size: var(--fs-small);
+}
+.error {
+ color: var(--danger);
+}
+.code {
+ font-family: var(--font-mono);
+}
+.grow {
+ flex: 1;
+ min-width: 0;
+}
+
+.area {
+ flex: 1;
+ min-width: 0;
+ padding: 4px 6px;
+ border: 0;
+ border-radius: var(--radius-small);
+ box-shadow: inset 0 0 0 1px var(--border-strong);
+ background: var(--bg-input);
+ color: var(--fg);
+ font-family: var(--font-mono);
+ font-size: var(--fs-small);
+ line-height: 1.45;
+ resize: vertical;
+}
+.area:focus {
+ outline: none;
+ box-shadow: inset 0 0 0 2px var(--accent);
+}
+.area::placeholder {
+ color: var(--fg-muted);
+}
+.invalid,
+.invalid:focus {
+ box-shadow: inset 0 0 0 2px var(--danger);
+}
+
+.picker {
+ display: flex;
+ flex: 1;
+ align-items: center;
+ gap: 6px;
+ min-width: 0;
+ height: var(--h-control);
+ padding: 0 8px;
+ border: 0;
+ border-radius: var(--radius-small);
+ box-shadow: inset 0 0 0 1px var(--border-strong);
+ background: var(--bg-input);
+ color: var(--fg);
+ font: inherit;
+ text-align: left;
+}
+.picker:focus-visible {
+ outline: none;
+ box-shadow: inset 0 0 0 2px var(--accent);
+}
+.pickerText {
+ flex: 1;
+ min-width: 0;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+.placeholder {
+ color: var(--fg-muted);
+}
+.pickerPopup {
+ display: flex;
+ flex-direction: column;
+ gap: 6px;
+ width: 260px;
+ padding: 8px;
+}
+.pickerList {
+ display: flex;
+ flex-direction: column;
+ gap: 2px;
+ max-height: 240px;
+ overflow: auto;
+}
+
+.link {
+ padding: 0;
+ border: 0;
+ background: none;
+ color: var(--link);
+ font: inherit;
+ cursor: pointer;
+}
+.link:hover {
+ color: var(--link-hover);
+ text-decoration: underline;
+}
+.link:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
+}
+
+.dialogBody {
+ display: flex;
+ flex-direction: column;
+ gap: 8px;
+ padding: 12px 16px 4px;
+}
+/* Dialogs are wide enough for "Label: [control]". */
+.dialogBody .row {
+ display: grid;
+ grid-template-columns: 90px minmax(0, 1fr);
+ align-items: center;
+ column-gap: 8px;
+}
+.dialogBody .control {
+ align-items: center;
+}
diff --git a/src/features/tools/ServerSettings.tsx b/src/features/tools/ServerSettings.tsx
new file mode 100644
index 000000000..d16ff89e8
--- /dev/null
+++ b/src/features/tools/ServerSettings.tsx
@@ -0,0 +1,567 @@
+/**
+ * Settings › Language Servers, right-hand side: the selected tool's executable
+ * and, for a language server, its startup options and workspace configuration
+ * (`languageServers.<name>`), plus the New Language Server dialog. Edits are
+ * staged in the Settings dialog and written on Apply / OK.
+ */
+import { useEffect, useId, useMemo, useRef, useState, type ReactNode } from "react";
+import clsx from "clsx";
+import type { ToolInfo } from "@/bindings";
+import { Checkbox, Dialog, Icon, IconButton, Input, Popup, SearchField, T } from "@/ui";
+import { tx } from "@/platform/i18n";
+import { useSettingsForm } from "@/workbench/contributions";
+import { toolsBackend, type LanguageChoice } from "./backend";
+import {
+ formatArgs,
+ formatEnv,
+ formatJson,
+ formatList,
+ nameFromCommand,
+ parseArgs,
+ parseEnv,
+ parseJsonObject,
+ parseList,
+ SERVER_NAME,
+ serverKey,
+ toolPathKey,
+ type ServerEntry,
+ type ServerField,
+} from "./serverConfig";
+import styles from "./ServerSettings.module.css";
+
+let languageList: Promise<LanguageChoice[]> | null = null;
+
+/** Languages a server can be used for, loaded once. */
+export function useLanguageChoices(): LanguageChoice[] {
+ const [langs, setLangs] = useState<LanguageChoice[]>([]);
+ useEffect(() => {
+ let live = true;
+ languageList ??= toolsBackend()
+ .languages()
+ .catch(() => {
+ languageList = null;
+ return [];
+ });
+ void languageList.then((l) => live && setLangs(l));
+ return () => {
+ live = false;
+ };
+ }, []);
+ return langs;
+}
+
+/** Test hook: forget the loaded language list. */
+export function resetLanguageChoices() {
+ languageList = null;
+}
+
+export function languageNames(ids: readonly string[], known: readonly LanguageChoice[]): string[] {
+ return ids.map((id) => known.find((l) => l.id === id)?.name ?? id);
+}
+
+// ---------------------------------------------------------------------------
+// Form building blocks (IDEA layout: "Label: [control]", titled separators)
+
+/** A titled separator; `collapsible` ones fold away like IDEA's hideable separators. */
+function Section({
+ title,
+ note,
+ collapsible,
+ defaultOpen = true,
+ children,
+}: {
+ title: string;
+ note?: string;
+ collapsible?: boolean;
+ defaultOpen?: boolean;
+ children: ReactNode;
+}) {
+ const [open, setOpen] = useState(defaultOpen);
+ const shown = !collapsible || open;
+ return (
+ <section className={styles.section} aria-label={tx(title)}>
+ {collapsible ? (
+ <button
+ type="button"
+ className={clsx(styles.sectionTitle, styles.sectionToggle)}
+ aria-expanded={open}
+ onClick={() => setOpen(!open)}
+ >
+ <Icon name={open ? "chevron-down" : "chevron-right"} size={12} />
+ <T>{title}</T>
+ <span className={styles.sectionRule} aria-hidden />
+ </button>
+ ) : (
+ <div className={styles.sectionTitle}>
+ <T>{title}</T>
+ <span className={styles.sectionRule} aria-hidden />
+ </div>
+ )}
+ {shown && (
+ <div className={styles.sectionBody}>
+ {note && (
+ <div className={styles.note}>
+ <T>{note}</T>
+ </div>
+ )}
+ {children}
+ </div>
+ )}
+ </section>
+ );
+}
+
+/** "Label:" above its control (beside it in dialogs), the hint below. */
+function Row({
+ label,
+ htmlFor,
+ hint,
+ children,
+}: {
+ label: string;
+ htmlFor?: string;
+ hint?: ReactNode;
+ children: ReactNode;
+}) {
+ return (
+ <div className={styles.row}>
+ <label className={styles.label} htmlFor={htmlFor}>
+ <T>{label}</T>
+ </label>
+ <div className={styles.control}>{children}</div>
+ {hint && <div className={styles.hint}>{hint}</div>}
+ </div>
+ );
+}
+
+interface FieldProps<V> {
+ label: string;
+ value: V | undefined;
+ format: (v: V | undefined) => string;
+ /** Text → value (null removes the setting); throws with a message when invalid. */
+ parse: (text: string) => V | null;
+ onChange: (value: V | null) => void;
+ placeholder?: string;
+ hint?: ReactNode;
+ multiline?: boolean;
+ trailing?: ReactNode;
+}
+
+/**
+ * A text field over a setting: valid text is staged as it is typed; invalid
+ * text stays in the field, marked, and isn't staged.
+ */
+function Field<V>({ label, value, format, parse, onChange, placeholder, hint, multiline, trailing }: FieldProps<V>) {
+ const id = useId();
+ const [draft, setDraft] = useState<string | null>(null);
+ const [error, setError] = useState<string | null>(null);
+ const text = draft ?? format(value);
+ const change = (next: string) => {
+ setDraft(next);
+ try {
+ onChange(parse(next));
+ setError(null);
+ } catch (e) {
+ setError(e instanceof Error ? e.message : String(e));
+ }
+ };
+ const common = {
+ id,
+ value: text,
+ placeholder,
+ "aria-invalid": error ? true : undefined,
+ // Valid text is reformatted from the staged value once the field is left.
+ onBlur: () => !error && setDraft(null),
+ };
+ return (
+ <Row
+ label={label}
+ htmlFor={id}
+ hint={
+ error ? (
+ <span className={styles.error} role="alert">
+ {error}
+ </span>
+ ) : (
+ hint
+ )
+ }
+ >
+ {multiline ? (
+ <textarea
+ {...common}
+ spellCheck={false}
+ rows={Math.min(14, Math.max(3, text.split("\n").length + 1, (placeholder ?? "").split("\n").length))}
+ className={clsx(styles.area, error && styles.invalid)}
+ onChange={(e) => change(e.target.value)}
+ />
+ ) : (
+ <Input {...common} mono invalid={!!error} className={styles.grow} onChange={(e) => change(e.target.value)} />
+ )}
+ {trailing}
+ </Row>
+ );
+}
+
+/** "Python, TypeScript ▾": checkboxes in a popup, with a filter. */
+export function LanguagePicker({
+ id,
+ value,
+ onChange,
+ invalid,
+}: {
+ id?: string;
+ value: readonly string[];
+ onChange: (ids: string[]) => void;
+ invalid?: boolean;
+}) {
+ const known = useLanguageChoices();
+ const anchor = useRef<HTMLButtonElement>(null);
+ const [open, setOpen] = useState(false);
+ const [query, setQuery] = useState("");
+ const shown = useMemo(() => {
+ const q = query.trim().toLowerCase();
+ return q ? known.filter((l) => l.name.toLowerCase().includes(q) || l.id.includes(q)) : known;
+ }, [known, query]);
+ const label = languageNames(value, known).join(", ");
+ return (
+ <>
+ <button
+ id={id}
+ ref={anchor}
+ type="button"
+ aria-haspopup="dialog"
+ aria-expanded={open}
+ aria-invalid={invalid || undefined}
+ className={clsx(styles.picker, invalid && styles.invalid)}
+ onClick={() => setOpen(!open)}
+ >
+ <span className={clsx(styles.pickerText, !label && styles.placeholder)}>
+ {label || tx("Choose languages…")}
+ </span>
+ <Icon name="chevron-down" size={12} />
+ </button>
+ <Popup
+ open={open}
+ onClose={() => setOpen(false)}
+ anchor={anchor}
+ placement="bottom-start"
+ role="dialog"
+ aria-label={tx("Languages")}
+ className={styles.pickerPopup}
+ >
+ <SearchField
+ value={query}
+ onChange={setQuery}
+ placeholder="Filter languages"
+ aria-label="Filter languages"
+ data-autofocus
+ />
+ <div className={styles.pickerList}>
+ {shown.map((l) => (
+ <Checkbox
+ key={l.id}
+ checked={value.includes(l.id)}
+ label={l.name}
+ onChange={(on) => onChange(on ? [...value, l.id] : value.filter((v) => v !== l.id))}
+ />
+ ))}
+ {shown.length === 0 && (
+ <div className={styles.note}>
+ <T>No languages match.</T>
+ </div>
+ )}
+ </div>
+ </Popup>
+ </>
+ );
+}
+
+// ---------------------------------------------------------------------------
+// The tool's settings
+
+function useServerEntry(name: string): ServerEntry {
+ const form = useSettingsForm();
+ return (form.useValue(serverKey(name)) ?? {}) as ServerEntry;
+}
+
+/** Where the executable was found, or what is wrong with it. */
+function executableHint(tool: ToolInfo, pending: boolean): ReactNode {
+ if (pending) return <T>Checked when the settings are applied.</T>;
+ if (tool.customError) return <span className={styles.error}>{tool.customError}</span>;
+ if (tool.path) {
+ return (
+ <>
+ <T>Using</T> <code className={styles.code}>{tool.path}</code>
+ {tool.version && <> ({tool.version})</>}
+ </>
+ );
+ }
+ return tool.installHint ?? <T>Not found on PATH.</T>;
+}
+
+function ExecutableRow({ tool, pending }: { tool: ToolInfo; pending: boolean }) {
+ const form = useSettingsForm();
+ const entry = useServerEntry(tool.name);
+ const custom = (entry.languages?.length ?? 0) > 0;
+ // A server defined in settings names its executable itself; others may point elsewhere.
+ const key = custom ? serverKey(tool.name, "command") : toolPathKey(tool.command);
+ const tools = form.useValue("tools") as Record<string, { path: string }> | undefined;
+ const value = custom ? entry.command : tools?.[tool.command]?.path;
+ const set = (path: string | null) => {
+ if (custom || !tool.command.includes(".")) form.set(key, path);
+ else {
+ // A command with dots can't be a key segment: replace the map.
+ const next = { ...tools };
+ if (path) next[tool.command] = { path };
+ else delete next[tool.command];
+ form.set("tools", next);
+ }
+ };
+ return (
+ <Field<string>
+ key={key}
+ label={custom ? "Command" : "Path"}
+ value={value}
+ format={(v) => v ?? ""}
+ parse={(t) => t.trim() || null}
+ onChange={set}
+ placeholder={custom ? tx("Executable name or path") : tx("Auto-detect")}
+ hint={executableHint(tool, pending)}
+ trailing={
+ <IconButton
+ icon="folder-open"
+ size="small"
+ title="Browse…"
+ onClick={async () => {
+ const picked = await toolsBackend().chooseExecutable(tx`Select ${tool.command || tool.name}`, value);
+ if (picked) set(picked);
+ }}
+ />
+ }
+ />
+ );
+}
+
+/** Debug adapters: only where the executable is. */
+export function ToolSettings({ tool }: { tool: ToolInfo }) {
+ return (
+ <Section title="Executable">
+ <ExecutableRow tool={tool} pending={false} />
+ </Section>
+ );
+}
+
+/** A language server: on/off, executable, startup options, workspace configuration. */
+export function ServerSettings({ tool, pending }: { tool: ToolInfo; pending: boolean }) {
+ const form = useSettingsForm();
+ const entry = useServerEntry(tool.name);
+ const custom = (entry.languages?.length ?? 0) > 0;
+ const set = (field: ServerField) => (value: unknown) => form.set(serverKey(tool.name, field), value);
+ const known = useLanguageChoices();
+ const languagesId = useId();
+ const languages = custom ? languageNames(entry.languages ?? [], known) : tool.languages;
+ const defaultOptions = useMemo(() => {
+ try {
+ return tool.defaultInitializationOptions ? JSON.parse(tool.defaultInitializationOptions) : null;
+ } catch {
+ return null;
+ }
+ }, [tool.defaultInitializationOptions]);
+ const overridden = !custom && Object.keys(entry).length > 0;
+
+ return (
+ <div className={styles.form}>
+ <Checkbox
+ checked={entry.enabled !== false}
+ label={
+ languages.length ? tx`Use ${tool.displayName} for ${languages.join(", ")} files` : tx`Use ${tool.displayName}`
+ }
+ // Enabled is the default; a project says so explicitly to win over a global "off".
+ onChange={(on) => set("enabled")(on ? (form.scope === "project" ? true : null) : false)}
+ />
+
+ <Section title="Executable">
+ <ExecutableRow tool={tool} pending={pending} />
+ {custom && (
+ <>
+ <Row label="Languages" htmlFor={languagesId}>
+ <LanguagePicker
+ id={languagesId}
+ value={entry.languages ?? []}
+ invalid={!entry.languages?.length}
+ onChange={(ids) => set("languages")(ids.length ? ids : null)}
+ />
+ </Row>
+ <Field<string[]>
+ label="Root markers"
+ value={entry.rootMarkers}
+ format={formatList}
+ parse={parseList}
+ onChange={set("rootMarkers")}
+ placeholder="pyproject.toml, .git"
+ hint={<T>Files marking the workspace root.</T>}
+ />
+ </>
+ )}
+ </Section>
+
+ <Section
+ title="Startup"
+ note="Changing these restarts the server."
+ collapsible
+ defaultOpen={!!(entry.args || entry.env || entry.initializationOptions)}
+ >
+ <Field<string[]>
+ label="Arguments"
+ value={entry.args ?? undefined}
+ format={formatArgs}
+ parse={parseArgs}
+ onChange={set("args")}
+ placeholder={formatArgs(tool.defaultArgs) || tx("None")}
+ />
+ <Field<Record<string, string>>
+ label="Environment variables"
+ value={entry.env}
+ format={formatEnv}
+ parse={parseEnv}
+ onChange={set("env")}
+ placeholder="NAME=value; OTHER=value"
+ />
+ <Field<Record<string, unknown>>
+ label="Initialization options"
+ multiline
+ value={entry.initializationOptions as Record<string, unknown> | undefined}
+ format={formatJson}
+ parse={parseJsonObject}
+ onChange={set("initializationOptions")}
+ placeholder={defaultOptions ? formatJson(defaultOptions) : '{ "key": "value" }'}
+ hint={defaultOptions ? <T>Merged over the defaults shown when empty.</T> : undefined}
+ />
+ </Section>
+
+ <Section
+ title="Workspace Configuration"
+ note="Sent to the running server; no restart needed."
+ collapsible
+ defaultOpen={!!entry.settings}
+ >
+ <Field<Record<string, unknown>>
+ label="Settings"
+ multiline
+ value={entry.settings as Record<string, unknown> | undefined}
+ format={formatJson}
+ parse={parseJsonObject}
+ onChange={set("settings")}
+ placeholder={'{ "section": { "key": "value" } }'}
+ />
+ </Section>
+
+ {overridden && (
+ <div>
+ <button type="button" className={styles.link} onClick={() => form.set(serverKey(tool.name), null)}>
+ <T>Restore Defaults</T>
+ </button>
+ </div>
+ )}
+ </div>
+ );
+}
+
+// ---------------------------------------------------------------------------
+// New Language Server
+
+/** Asks for a name, command and languages; stages the new server on OK. */
+export function NewServerDialog({
+ existing,
+ onClose,
+ onAdded,
+}: {
+ existing: readonly string[];
+ onClose: () => void;
+ onAdded: (name: string) => void;
+}) {
+ const form = useSettingsForm();
+ const ids = { name: useId(), command: useId(), languages: useId() };
+ const [commandLine, setCommandLine] = useState("");
+ const [name, setName] = useState<string | null>(null);
+ const [languages, setLanguages] = useState<string[]>([]);
+ // "ruff server": the executable, then its arguments.
+ let words: string[] = [];
+ let quoteError: string | null = null;
+ try {
+ words = parseArgs(commandLine) ?? [];
+ } catch (e) {
+ quoteError = e instanceof Error ? e.message : String(e);
+ }
+ const [command = "", ...args] = words;
+ const effectiveName = (name ?? nameFromCommand(command)).trim();
+ const problem =
+ quoteError ??
+ (!command
+ ? tx("Enter the command that starts the server.")
+ : !SERVER_NAME.test(effectiveName)
+ ? tx("Name: letters, digits, - _ + only.")
+ : existing.includes(effectiveName)
+ ? tx`${effectiveName} already exists.`
+ : !languages.length
+ ? tx("Choose the languages it serves.")
+ : null);
+ const add = () => {
+ if (problem) return;
+ const entry: ServerEntry = { command, languages };
+ if (args.length) entry.args = args;
+ form.set(serverKey(effectiveName), entry);
+ onAdded(effectiveName);
+ };
+ return (
+ <Dialog
+ open
+ onClose={onClose}
+ title={tx("New Language Server")}
+ width={480}
+ buttons={[
+ { label: "OK", role: "default", disabled: !!problem, title: problem ?? undefined, onClick: add },
+ { label: "Cancel", role: "cancel" },
+ ]}
+ >
+ <div className={styles.dialogBody}>
+ <Row label="Command" htmlFor={ids.command}>
+ <Input
+ id={ids.command}
+ mono
+ autoFocus
+ className={styles.grow}
+ value={commandLine}
+ placeholder="ruff server"
+ onChange={(e) => setCommandLine(e.target.value)}
+ />
+ <IconButton
+ icon="folder-open"
+ size="small"
+ title="Browse…"
+ onClick={async () => {
+ const picked = await toolsBackend().chooseExecutable(tx("Select the server executable"), command);
+ if (picked) setCommandLine(formatArgs([picked, ...args]));
+ }}
+ />
+ </Row>
+ <Row label="Name" htmlFor={ids.name}>
+ <Input
+ id={ids.name}
+ mono
+ className={styles.grow}
+ value={name ?? nameFromCommand(command)}
+ onChange={(e) => setName(e.target.value)}
+ />
+ </Row>
+ <Row label="Languages" htmlFor={ids.languages}>
+ <LanguagePicker id={ids.languages} value={languages} onChange={setLanguages} />
+ </Row>
+ <div className={styles.note}>
+ {problem ?? <T>Any language server that talks LSP over stdio, with its arguments.</T>}
+ </div>
+ </div>
+ </Dialog>
+ );
+}
diff --git a/src/features/tools/__tests__/serverSettings.test.tsx b/src/features/tools/__tests__/serverSettings.test.tsx
new file mode 100644
index 000000000..d7115024f
--- /dev/null
+++ b/src/features/tools/__tests__/serverSettings.test.tsx
@@ -0,0 +1,169 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { render, screen, waitFor, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { useProject } from "@/platform/project";
+import { provideNotificationService } from "@/workbench/contributions";
+import { MemoryToolsBackend, sampleTools, setToolsBackend } from "../backend";
+import { LanguageServersPage } from "../LanguageServersPage";
+import { resetLanguageChoices } from "../ServerSettings";
+import { useTools } from "../store";
+import { formatArgs, nameFromCommand, parseArgs, parseEnv, parseJsonObject, parseList } from "../serverConfig";
+import { resetTestForm, stagedFor, TestSettingsForm, useTestForm } from "./settingsForm";
+
+describe("server settings text fields", () => {
+ it("splits arguments like a shell and formats them back", () => {
+ expect(parseArgs(`--stdio --log "a b" 'c"d' e\\ f`)).toEqual(["--stdio", "--log", "a b", 'c"d', "e f"]);
+ expect(parseArgs(" ")).toBeNull();
+ expect(parseArgs('""')).toEqual([""]);
+ expect(() => parseArgs('"open')).toThrow(/Unclosed/);
+ const args = ["--x", "a b", 'q"t', ""];
+ expect(parseArgs(formatArgs(args))).toEqual(args);
+ });
+
+ it("parses environment variables separated by semicolons", () => {
+ expect(parseEnv("A=1; B_2 = x=y;\n C=")).toEqual({ A: "1", B_2: "x=y", C: "" });
+ expect(parseEnv(" ; ")).toBeNull();
+ expect(() => parseEnv("A=1; nope")).toThrow("Expected NAME=value: nope");
+ });
+
+ it("accepts JSON objects without nulls", () => {
+ expect(parseJsonObject('{ "a": { "b": [1] } }')).toEqual({ a: { b: [1] } });
+ expect(parseJsonObject(" ")).toBeNull();
+ expect(() => parseJsonObject("[1]")).toThrow("Expected a JSON object");
+ expect(() => parseJsonObject('{ "a": { "b": null } }')).toThrow("at a.b");
+ expect(() => parseJsonObject("{")).toThrow();
+ });
+
+ it("splits lists and names servers after their executable", () => {
+ expect(parseList("python, typescript python")).toEqual(["python", "typescript"]);
+ expect(parseList(",")).toBeNull();
+ expect(nameFromCommand("/opt/bin/ruff")).toBe("ruff");
+ expect(nameFromCommand("C:\\tools\\my server.exe")).toBe("my-server");
+ });
+});
+
+describe("Language Servers page settings", () => {
+ let backend: MemoryToolsBackend;
+ const listItem = (name: string) =>
+ screen.getByRole("list", { name: /language servers/i }).querySelector<HTMLElement>(`[data-tool="${name}"]`);
+ const details = (name: string) => screen.getByLabelText(`${name} details`);
+ const renderPage = () =>
+ render(
+ <TestSettingsForm>
+ <LanguageServersPage />
+ </TestSettingsForm>,
+ );
+
+ beforeEach(() => {
+ provideNotificationService({ notify: () => {} });
+ backend = new MemoryToolsBackend(
+ sampleTools().map((t) =>
+ t.name === "rust-analyzer"
+ ? { ...t, defaultArgs: ["--stdio"], defaultInitializationOptions: '{"checkOnSave":true}' }
+ : t,
+ ),
+ 1,
+ );
+ setToolsBackend(backend);
+ resetLanguageChoices();
+ resetTestForm();
+ useTools.setState({ tools: [], loaded: false, loading: false, error: null, jobs: {}, logs: {} });
+ useProject.setState({ project: null, settings: null });
+ });
+
+ afterEach(() => setToolsBackend(null));
+
+ it("stages startup options, showing the defaults they replace", async () => {
+ const user = userEvent.setup();
+ renderPage();
+ const pane = await screen.findByLabelText("rust-analyzer details");
+ // Folded while nothing is set there.
+ expect(within(pane).queryByRole("textbox", { name: "Arguments" })).toBeNull();
+ await user.click(within(pane).getByRole("button", { name: "Startup" }));
+ const args = within(pane).getByRole("textbox", { name: "Arguments" });
+ expect(args).toHaveAttribute("placeholder", "--stdio");
+ expect(within(pane).getByRole("textbox", { name: "Initialization options" })).toHaveAttribute(
+ "placeholder",
+ JSON.stringify({ checkOnSave: true }, null, 2),
+ );
+
+ await user.type(args, '--log "a b"');
+ expect(stagedFor("languageServers.rust-analyzer.args")).toEqual(["--log", "a b"]);
+ await user.type(within(pane).getByRole("textbox", { name: "Environment variables" }), "RA_LOG=info");
+ expect(stagedFor("languageServers.rust-analyzer.env")).toEqual({ RA_LOG: "info" });
+
+ // Invalid JSON is marked and not staged; valid JSON is.
+ const init = within(pane).getByRole("textbox", { name: "Initialization options" });
+ await user.click(init);
+ await user.paste('{ "check": null }');
+ expect(within(pane).getByRole("alert")).toHaveTextContent("null is not supported");
+ expect(stagedFor("languageServers.rust-analyzer.initializationOptions")).toBeUndefined();
+ await user.clear(init);
+ await user.paste('{ "check": { "command": "clippy" } }');
+ expect(stagedFor("languageServers.rust-analyzer.initializationOptions")).toEqual({ check: { command: "clippy" } });
+
+ // Turned off: marked in the list.
+ await user.click(within(pane).getByRole("checkbox", { name: /Use rust-analyzer for Rust files/ }));
+ expect(stagedFor("languageServers.rust-analyzer.enabled")).toBe(false);
+ expect(listItem("rust-analyzer")).toHaveTextContent("Disabled");
+
+ await user.click(within(pane).getByRole("button", { name: "Restore Defaults" }));
+ expect(stagedFor("languageServers.rust-analyzer")).toBeNull();
+ expect(listItem("rust-analyzer")).not.toHaveTextContent("Disabled");
+ expect(args).toHaveValue("");
+ });
+
+ it("adds a server of one's own from its command line, then removes it", async () => {
+ const user = userEvent.setup();
+ renderPage();
+ await screen.findByLabelText("rust-analyzer details");
+ await user.click(screen.getByRole("button", { name: "Add Language Server…" }));
+ const dialog = screen.getByRole("dialog", { name: "New Language Server" });
+ const ok = within(dialog).getByRole("button", { name: "OK" });
+ await user.type(within(dialog).getByRole("textbox", { name: "Command" }), "/opt/bin/ruff server");
+ expect(within(dialog).getByRole("textbox", { name: "Name" })).toHaveValue("ruff");
+ expect(ok).toBeDisabled();
+ expect(dialog).toHaveTextContent("Choose the languages it serves.");
+
+ const picker = within(dialog).getByRole("button", { name: "Languages" });
+ expect(picker).toHaveTextContent("Choose languages…");
+ await user.click(picker);
+ await user.click(await screen.findByRole("checkbox", { name: "Python" }));
+ await user.keyboard("{Escape}");
+ expect(picker).toHaveTextContent("Python");
+ await user.click(ok);
+
+ expect(stagedFor("languageServers.ruff")).toEqual({
+ command: "/opt/bin/ruff",
+ args: ["server"],
+ languages: ["python"],
+ });
+ // Listed and selected before Apply, as a new server.
+ await waitFor(() => expect(listItem("ruff")).toHaveAttribute("aria-current", "true"));
+ expect(listItem("ruff")).toHaveTextContent("New");
+ const pane = details("ruff");
+ expect(within(pane).getByRole("textbox", { name: "Command" })).toHaveValue("/opt/bin/ruff");
+ expect(within(pane).getByRole("textbox", { name: "Arguments" })).toHaveValue("server");
+ expect(pane).toHaveTextContent("Checked when the settings are applied.");
+
+ // Edits go into the staged entry.
+ await user.type(within(pane).getByRole("textbox", { name: "Root markers" }), "pyproject.toml");
+ expect(useTestForm.getState().values).toMatchObject({
+ languageServers: { ruff: { rootMarkers: ["pyproject.toml"] } },
+ });
+
+ await user.click(screen.getByRole("button", { name: "Remove Language Server" }));
+ expect(stagedFor("languageServers.ruff")).toBeNull();
+ expect(listItem("ruff")).toBeNull();
+ });
+
+ it("keeps the remove button for servers of one's own", async () => {
+ const user = userEvent.setup();
+ resetTestForm({ languageServers: { ruff: { command: "ruff", languages: ["python"] } } });
+ renderPage();
+ await screen.findByLabelText("rust-analyzer details");
+ expect(screen.getByRole("button", { name: "Remove Language Server" })).toBeDisabled();
+ await user.click(listItem("ruff")!);
+ expect(screen.getByRole("button", { name: "Remove Language Server" })).toBeEnabled();
+ });
+});
diff --git a/src/features/tools/__tests__/settingsForm.tsx b/src/features/tools/__tests__/settingsForm.tsx
new file mode 100644
index 000000000..5682aea7c
--- /dev/null
+++ b/src/features/tools/__tests__/settingsForm.tsx
@@ -0,0 +1,48 @@
+/** A Settings dialog stand-in: a page's form over plain values, staging into `staged`. */
+import { useMemo, type ReactNode } from "react";
+import { create } from "zustand";
+import { SettingsFormContext, type SettingsForm } from "@/workbench/contributions";
+
+interface FormState {
+ values: Record<string, unknown>;
+ /** Staged writes in order, as `settingsSet` would get them on Apply. */
+ staged: Array<[string, unknown]>;
+}
+
+export const useTestForm = create<FormState>(() => ({ values: {}, staged: [] }));
+
+const getAt = (v: unknown, key: string) =>
+ key
+ .split(".")
+ .reduce<unknown>((cur, k) => (cur && typeof cur === "object" ? (cur as Record<string, unknown>)[k] : undefined), v);
+
+function putAt(source: unknown, key: string, value: unknown): Record<string, unknown> {
+ const [head, ...rest] = key.split(".");
+ const base = { ...(source as Record<string, unknown> | undefined) };
+ if (rest.length) base[head!] = putAt(base[head!], rest.join("."), value);
+ else if (value == null) delete base[head!];
+ else base[head!] = value;
+ return base;
+}
+
+export function resetTestForm(values: Record<string, unknown> = {}) {
+ useTestForm.setState({ values, staged: [] });
+}
+
+/** The last value staged for `key`. */
+export function stagedFor(key: string): unknown {
+ return useTestForm.getState().staged.findLast(([k]) => k === key)?.[1];
+}
+
+export function TestSettingsForm({ children }: { children: ReactNode }) {
+ const form = useMemo<SettingsForm>(
+ () => ({
+ scope: "global",
+ useValue: (key) => useTestForm((s) => getAt(s.values, key)),
+ set: (key, value) =>
+ useTestForm.setState((s) => ({ values: putAt(s.values, key, value), staged: [...s.staged, [key, value]] })),
+ }),
+ [],
+ );
+ return <SettingsFormContext.Provider value={form}>{children}</SettingsFormContext.Provider>;
+}
diff --git a/src/features/tools/__tests__/tools.test.tsx b/src/features/tools/__tests__/tools.test.tsx
index 480ec419d..7a37e9c11 100644
--- a/src/features/tools/__tests__/tools.test.tsx
+++ b/src/features/tools/__tests__/tools.test.tsx
@@ -8,6 +8,7 @@ import { MemoryToolsBackend, sampleTools, setToolsBackend } from "../backend";
import { cancelInstall, installTool, refreshTools, uninstallTool, useTools } from "../store";
import { filterTools, LanguageServersPage } from "../LanguageServersPage";
import { installMissingServerPrompts, missingKey } from "../missing";
+import { resetTestForm, stagedFor, TestSettingsForm } from "./settingsForm";
type Note = Parameters<NotificationService["notify"]>[0];
let notes: Note[];
@@ -126,12 +127,19 @@ describe("missing language server prompt", () => {
});
describe("LanguageServersPage", () => {
+ beforeEach(() => resetTestForm());
+ const renderPage = () =>
+ render(
+ <TestSettingsForm>
+ <LanguageServersPage />
+ </TestSettingsForm>,
+ );
const listItem = (name: string) =>
screen.getByRole("list", { name: /language servers/i }).querySelector<HTMLElement>(`[data-tool="${name}"]`)!;
it("lists tools and installs from the details pane", async () => {
const user = userEvent.setup();
- render(<LanguageServersPage />);
+ renderPage();
await screen.findByText("gopls");
await user.click(listItem("gopls"));
const details = screen.getByLabelText("gopls details");
@@ -148,7 +156,7 @@ describe("LanguageServersPage", () => {
it("explains why a tool cannot be installed", async () => {
const user = userEvent.setup();
- render(<LanguageServersPage />);
+ renderPage();
await screen.findByText("solargraph");
await user.click(listItem("solargraph"));
expect(screen.getByText("gem install solargraph")).toBeInTheDocument();
@@ -156,23 +164,26 @@ describe("LanguageServersPage", () => {
expect(screen.getByText("curl is required to download tools")).toBeInTheDocument();
});
- it("sets and clears a custom path", async () => {
+ it("stages and clears a custom path", async () => {
const user = userEvent.setup();
- render(<LanguageServersPage />);
+ renderPage();
await screen.findByText("gopls");
await user.click(listItem("gopls"));
const path = within(screen.getByLabelText("gopls details")).getByRole("textbox", { name: "Path" });
- await user.type(path, "/opt/go/bin/gopls{Enter}");
- await waitFor(() => expect(screen.getByLabelText("gopls details")).toHaveTextContent("Custom"));
- expect(backend.customPaths).toEqual({ gopls: "/opt/go/bin/gopls" });
- await user.click(screen.getByRole("button", { name: "Use auto-detected" }));
- await waitFor(() => expect(backend.customPaths).toEqual({}));
- expect(screen.getByLabelText("gopls details")).toHaveTextContent("Missing");
+ await user.type(path, "/opt/go/bin/gopls");
+ expect(stagedFor("tools.gopls.path")).toBe("/opt/go/bin/gopls");
+ await user.clear(path);
+ expect(stagedFor("tools.gopls.path")).toBeNull();
+ // Picked with the file chooser.
+ backend.chosen = "/usr/local/bin/gopls";
+ await user.click(within(screen.getByLabelText("gopls details")).getByRole("button", { name: "Browse…" }));
+ expect(stagedFor("tools.gopls.path")).toBe("/usr/local/bin/gopls");
+ expect(path).toHaveValue("/usr/local/bin/gopls");
});
it("moves the selection with the arrow keys", async () => {
const user = userEvent.setup();
- render(<LanguageServersPage />);
+ renderPage();
await screen.findByText("gopls");
await user.click(listItem("rust-analyzer"));
await user.keyboard("{ArrowDown}");
@@ -181,7 +192,7 @@ describe("LanguageServersPage", () => {
it("filters to missing tools", async () => {
const user = userEvent.setup();
- render(<LanguageServersPage />);
+ renderPage();
await screen.findByText("gopls");
await user.click(screen.getByRole("radio", { name: /missing/i }));
expect(screen.queryByText("rust-analyzer")).not.toBeInTheDocument();
@@ -193,7 +204,7 @@ describe("LanguageServersPage", () => {
it("shows backend errors", async () => {
vi.spyOn(backend, "list").mockRejectedValueOnce(new Error("boom"));
- render(<LanguageServersPage />);
+ renderPage();
expect(await screen.findByRole("alert")).toHaveTextContent("boom");
});
});
diff --git a/src/features/tools/backend.ts b/src/features/tools/backend.ts
index 4083162da..4aca205f8 100644
--- a/src/features/tools/backend.ts
+++ b/src/features/tools/backend.ts
@@ -5,7 +5,11 @@
import { Channel } from "@tauri-apps/api/core";
import type { InstallEvent, RequestId, ToolInfo } from "@/bindings";
import { call, commands, IpcError, isTauri } from "@/platform/ipc";
-import { useProject } from "@/platform/project";
+
+export interface LanguageChoice {
+ id: string;
+ name: string;
+}
export interface ToolsBackend {
list(): Promise<ToolInfo[]>;
@@ -14,10 +18,10 @@ export interface ToolsBackend {
cancel(request: RequestId): void;
/** Restarts running language servers named `name` (after an install). */
restartServers(name: string): Promise<void>;
- /** Launches `command` from `path` instead of the detected one (global setting); "" clears it. */
- setCustomPath(command: string, path: string): Promise<void>;
/** File chooser for an executable; null when cancelled. */
chooseExecutable(title: string, defaultPath?: string): Promise<string | null>;
+ /** Languages a server defined in settings can serve. */
+ languages(): Promise<LanguageChoice[]>;
}
export const tauriToolsBackend: ToolsBackend = {
@@ -40,18 +44,13 @@ export const tauriToolsBackend: ToolsBackend = {
servers.filter((s) => s.name === name).map((s) => call(commands.lspRestart(s.id)).catch(() => {})),
);
},
- setCustomPath: async (command, path) => {
- const tools = { ...(await commands.settingsGet()).tools };
- if (path) tools[command] = { path };
- else delete tools[command];
- const settings = await call(commands.settingsSet("global", "tools", JSON.stringify(tools)));
- useProject.setState({ settings });
- },
chooseExecutable: async (title, defaultPath) => {
const { open } = await import("@tauri-apps/plugin-dialog");
const picked = await open({ directory: false, multiple: false, title, defaultPath: defaultPath || undefined });
return (Array.isArray(picked) ? picked[0] : picked) ?? null;
},
+ languages: async () =>
+ (await commands.languages()).map((l) => ({ id: l.id, name: l.name })).sort((a, b) => a.name.localeCompare(b.name)),
};
function tool(partial: Partial<ToolInfo> & Pick<ToolInfo, "name" | "languages">): ToolInfo {
@@ -69,6 +68,8 @@ function tool(partial: Partial<ToolInfo> & Pick<ToolInfo, "name" | "languages">)
installHint: null,
homepage: null,
customError: null,
+ defaultArgs: [],
+ defaultInitializationOptions: null,
...partial,
};
}
@@ -202,22 +203,21 @@ export class MemoryToolsBackend implements ToolsBackend {
this.restarted.push(name);
}
- /** Paths set through `setCustomPath`, by command. */
- customPaths: Record<string, string> = {};
/** What `chooseExecutable` answers. */
chosen: string | null = null;
- async setCustomPath(command: string, path: string) {
- if (path) this.customPaths[command] = path;
- else delete this.customPaths[command];
- for (const t of this.tools.filter((x) => x.command === command)) {
- this.replace(path ? { ...t, status: "custom", path, version: null } : { ...t, status: "missing", path: null });
- }
- }
-
async chooseExecutable() {
return this.chosen;
}
+
+ async languages() {
+ return [
+ { id: "go", name: "Go" },
+ { id: "python", name: "Python" },
+ { id: "rust", name: "Rust" },
+ { id: "typescript", name: "TypeScript" },
+ ];
+ }
}
let backend: ToolsBackend | null = null;
diff --git a/src/features/tools/index.ts b/src/features/tools/index.ts
index 37993487d..5086f5781 100644
--- a/src/features/tools/index.ts
+++ b/src/features/tools/index.ts
@@ -19,7 +19,19 @@ export function activateSettingsPages(): () => void {
title: "Language Servers",
group: "Languages & Frameworks",
order: 400,
- keywords: ["lsp", "language server", "debugger", "adapter", "dap", "install", "rust-analyzer", "gopls", "pyright"],
+ keywords: [
+ "lsp",
+ "language server",
+ "debugger",
+ "adapter",
+ "dap",
+ "install",
+ "initialization options",
+ "rust-analyzer",
+ "gopls",
+ "pyright",
+ ],
+ projectScope: true,
component: lazyComponent(() => import("./LanguageServersPage").then((m) => m.LanguageServersPage)),
});
}
diff --git a/src/features/tools/serverConfig.ts b/src/features/tools/serverConfig.ts
new file mode 100644
index 000000000..00ab9118c
--- /dev/null
+++ b/src/features/tools/serverConfig.ts
@@ -0,0 +1,119 @@
+/**
+ * Settings › Language Servers entries (`languageServers.<name>` in settings.toml):
+ * text ↔ value conversions for the editor fields. Parsers return `null` for an
+ * empty field (the setting is removed) and throw `Error` with a user-facing message.
+ */
+import type { LanguageServerSettings } from "@/bindings";
+
+/** What the settings set for a server (any field may be absent). */
+export type ServerEntry = Partial<LanguageServerSettings>;
+export type ServerField = keyof LanguageServerSettings;
+
+/** Settings keys of a server's entry and of a tool's executable. */
+export const serverKey = (name: string, field?: ServerField) =>
+ field ? `languageServers.${name}.${field}` : `languageServers.${name}`;
+export const toolPathKey = (command: string) => `tools.${command}.path`;
+
+/** The server's name proposed for an executable (`/opt/bin/ruff` → `ruff`). */
+export function nameFromCommand(command: string): string {
+ const base = command.trim().split(/[\\/]/).pop() ?? "";
+ return base.replace(/\.(exe|cmd|bat)$/i, "").replace(/[^A-Za-z0-9_+-]/g, "-");
+}
+
+/** Names become settings keys: no dots or spaces. */
+export const SERVER_NAME = /^[A-Za-z0-9][A-Za-z0-9_+-]*$/;
+
+/** Shell-like split: whitespace separates, quotes group, backslash escapes. */
+export function parseArgs(text: string): string[] | null {
+ const out: string[] = [];
+ let cur = "";
+ let started = false;
+ let quote: '"' | "'" | null = null;
+ for (let i = 0; i < text.length; i++) {
+ const c = text[i]!;
+ if (quote) {
+ if (c === quote) quote = null;
+ else if (c === "\\" && quote === '"' && i + 1 < text.length) cur += text[++i];
+ else cur += c;
+ } else if (c === '"' || c === "'") {
+ quote = c;
+ started = true;
+ } else if (c === "\\" && i + 1 < text.length) {
+ cur += text[++i];
+ started = true;
+ } else if (/\s/.test(c)) {
+ if (started) out.push(cur);
+ cur = "";
+ started = false;
+ } else {
+ cur += c;
+ started = true;
+ }
+ }
+ if (quote) throw new Error(`Unclosed ${quote} quote`);
+ if (started) out.push(cur);
+ return out.length ? out : null;
+}
+
+export function formatArgs(args: readonly string[] | undefined | null): string {
+ return (args ?? []).map((a) => (a === "" || /[\s"'\\]/.test(a) ? `"${a.replace(/["\\]/g, "\\$&")}"` : a)).join(" ");
+}
+
+/** `NAME=value` pairs separated by `;` (or new lines), as in run configurations. */
+export function parseEnv(text: string): Record<string, string> | null {
+ const env: Record<string, string> = {};
+ for (const raw of text.split(/[;\n]/)) {
+ const pair = raw.trim();
+ if (!pair) continue;
+ const eq = pair.indexOf("=");
+ const key = eq < 0 ? "" : pair.slice(0, eq).trim();
+ if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) throw new Error(`Expected NAME=value: ${pair}`);
+ env[key] = pair.slice(eq + 1).trim();
+ }
+ return Object.keys(env).length ? env : null;
+}
+
+export function formatEnv(env: Record<string, string> | undefined | null): string {
+ return Object.entries(env ?? {})
+ .map(([k, v]) => `${k}=${v}`)
+ .join("; ");
+}
+
+/** A JSON object (settings.toml has no `null`, so neither may the object). */
+export function parseJsonObject(text: string): Record<string, unknown> | null {
+ if (!text.trim()) return null;
+ let value: unknown;
+ try {
+ value = JSON.parse(text);
+ } catch (e) {
+ throw new Error(e instanceof Error ? e.message : String(e), { cause: e });
+ }
+ if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Expected a JSON object");
+ const nullAt = findNull(value, "");
+ if (nullAt !== null) throw new Error(`null is not supported (at ${nullAt || "top level"})`);
+ return value as Record<string, unknown>;
+}
+
+function findNull(v: unknown, path: string): string | null {
+ if (v === null) return path;
+ if (typeof v !== "object") return null;
+ for (const [k, child] of Object.entries(v as Record<string, unknown>)) {
+ const hit = findNull(child, Array.isArray(v) ? `${path}[${k}]` : path ? `${path}.${k}` : k);
+ if (hit !== null) return hit;
+ }
+ return null;
+}
+
+export function formatJson(value: unknown): string {
+ return value == null ? "" : JSON.stringify(value, null, 2);
+}
+
+/** Comma / whitespace separated names. */
+export function parseList(text: string): string[] | null {
+ const items = text.split(/[\s,]+/).filter(Boolean);
+ return items.length ? [...new Set(items)] : null;
+}
+
+export function formatList(items: readonly string[] | undefined | null): string {
+ return (items ?? []).join(", ");
+}
diff --git a/src/features/tools/store.ts b/src/features/tools/store.ts
index 76baa23b1..4c07e3a6c 100644
--- a/src/features/tools/store.ts
+++ b/src/features/tools/store.ts
@@ -180,23 +180,6 @@ export async function uninstallTool(name: string): Promise<boolean> {
}
}
-/** Launches `command` from `path` (empty: auto-detect again), then re-checks the tools. */
-export async function setCustomPath(command: string, path: string): Promise<boolean> {
- try {
- await toolsBackend().setCustomPath(command, path.trim());
- await refreshTools();
- return true;
- } catch (e) {
- notifications().notify({
- group: "tools",
- level: "error",
- title: `Failed to set the path of ${command}`,
- body: errorText(e),
- });
- return false;
- }
-}
-
export const STATUS_LABEL: Record<ToolInfo["status"], string> = {
installed: "Installed",
onPath: "On PATH",
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 133d2300d..d09f15885 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -847,6 +847,7 @@
"Hide Library Frames": "隐藏库帧",
"Hide Replace": "隐藏替换",
"Hide debug window on process termination": "进程终止时隐藏调试窗口",
+ "Auto-detect": "自动检测",
"Hide install log": "隐藏安装日志",
"Hierarchies": "层次结构",
"Hierarchy": "层次结构",
@@ -2384,14 +2385,11 @@
"Language server": "语言服务器",
"Path": "路径",
"Missing": "缺失",
- "Leave empty to use the IDE-installed copy, else the one on PATH.": "留空则使用 IDE 安装的副本,否则使用 PATH 上的版本。",
- "Installs into the IDE's own tools folder via": "安装到 IDE 自己的工具目录,方式:",
+ "Installs into the IDE's own tools folder via {installMethod}": "通过 {installMethod} 安装到 IDE 自己的工具文件夹",
"No tool selected": "未选择工具",
- "Use auto-detected": "使用自动检测",
"Custom": "自定义",
"On PATH": "PATH 中",
"Reinstall": "重新安装",
- "Auto-detect": "自动检测",
"Move focus to the Editor with Escape": "按 Escape 将焦点移到编辑器",
"Otherwise Escape goes to the shell.": "否则 Escape 发送给 shell。",
"Configure terminal keybindings": "配置终端快捷键",
@@ -3596,7 +3594,6 @@
"Failed to download JDK {version}": "下载 JDK {version} 失败",
"Java Settings…": "Java 设置…",
"{name} needs JDK {version} to run": "{name} 需要 JDK {version} 才能运行",
- "Failed to set the path of {command}": "设置 {command} 的路径失败",
"Search for branches, actions, repositories": "搜索分支、操作、仓库",
"Git Settings": "Git 设置",
"Repositories and branches": "仓库和分支",
@@ -3976,6 +3973,35 @@
"Delete the layout '{name}'?": "是否删除布局 '{name}'?",
"In {left}, not in {right}": "在 {left} 中,不在 {right} 中",
"Local branch '{local}' has commits that do not exist in '{remote}'. Rebase '{local}' onto '{remote}', or drop local commits?": "本地分支 '{local}' 有 '{remote}' 中不存在的提交。是将 '{local}' 变基到 '{remote}',还是丢弃本地提交?",
+ "Add Language Server…": "添加语言服务器…",
+ "Use {displayName}": "使用 {displayName}",
+ "Select {name}": "选择 {name}",
+ "Root markers": "根标记",
+ "Initialization options": "初始化选项",
+ "Global": "全局",
+ "This project": "此项目",
+ "Executable name or path": "可执行文件名或路径",
+ "Select the server executable": "选择服务器可执行文件",
+ "Remove Language Server": "移除语言服务器",
+ "Missing ({missingCount})": "缺失 ({missingCount})",
+ "Choose languages…": "选择语言…",
+ "Filter languages": "筛选语言",
+ "No languages match.": "没有匹配的语言。",
+ "Checked when the settings are applied.": "应用设置后检查。",
+ "Using": "使用",
+ "Not found on PATH.": "在 PATH 中未找到。",
+ "Use {displayName} for {join} files": "对 {join} 文件使用 {displayName}",
+ "Files marking the workspace root.": "标记工作区根目录的文件。",
+ "Merged over the defaults shown when empty.": "与默认值(为空时显示)合并。",
+ "Workspace Configuration": "工作区配置",
+ "Enter the command that starts the server.": "请输入启动服务器的命令。",
+ "Name: letters, digits, - _ + only.": "名称:只能包含字母、数字、- _ +。",
+ "{effectiveName} already exists.": "{effectiveName} 已存在。",
+ "Choose the languages it serves.": "请选择它服务的语言。",
+ "New Language Server": "新建语言服务器",
+ "Any language server that talks LSP over stdio, with its arguments.": "任何通过 stdio 使用 LSP 的语言服务器,可带参数。",
+ "Changing these restarts the server.": "修改这些设置会重启服务器。",
+ "Sent to the running server; no restart needed.": "发送给运行中的服务器,无需重启。",
"SSH Configurations": "SSH 配置",
"User name": "用户名",
"Authentication type": "身份验证类型",
diff --git a/src/platform/locales/textCatalog.test.ts b/src/platform/locales/textCatalog.test.ts
index 759d2746c..e24475c49 100644
--- a/src/platform/locales/textCatalog.test.ts
+++ b/src/platform/locales/textCatalog.test.ts
@@ -182,9 +182,13 @@ const UNTRANSLATED = new Set<string>([
"kebab-case",
"KEY=value; OTHER=value",
"NAME",
+ "NAME=value; OTHER=value",
"node_modules/typescript",
"PascalCase",
+ "pyproject.toml, .git",
+ "ruff server",
"snake_case",
+ '{ "section": { "key": "value" } }',
// Identifiers that only look like text: icon names, error codes, categories, console output
"app",
"cancelled",
diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.ts
index 9824bdf7e..0c67e9161 100644
--- a/src/workbench/contributions.ts
+++ b/src/workbench/contributions.ts
@@ -8,7 +8,15 @@
* The workbench renders whatever is registered; the action
* `toolwindow.<id>` toggles it (registered automatically).
*/
-import { useEffect, useRef, type ComponentType, type ReactNode, type RefObject } from "react";
+import {
+ createContext,
+ useContext,
+ useEffect,
+ useRef,
+ type ComponentType,
+ type ReactNode,
+ type RefObject,
+} from "react";
import type { RunConfig } from "@/bindings";
import type { MenuItem } from "@/ui/Menu";
import { create } from "zustand";
@@ -453,7 +461,10 @@ export interface EmbeddedTerminalOptions {
"aria-label"?: string;
}
-export type EmbeddedTerminalFactory = (host: HTMLElement, options: EmbeddedTerminalOptions) => Promise<EmbeddedTerminal>;
+export type EmbeddedTerminalFactory = (
+ host: HTMLElement,
+ options: EmbeddedTerminalOptions,
+) => Promise<EmbeddedTerminal>;
const services: {
editor?: EditorService;
@@ -587,6 +598,29 @@ export interface SettingsPageContribution {
/** Extra words matched by the settings search. */
keywords?: string[];
component: ComponentType;
+ /** The page edits settings that a project can override (Global / This project switch). */
+ projectScope?: boolean;
+}
+
+/**
+ * What a settings page edits through: values of the page's scope with the
+ * edits not applied yet. Edits are written on Apply / OK and dropped on Cancel.
+ */
+export interface SettingsForm {
+ scope: "global" | "project";
+ /** Value of a dotted key (map entries too, e.g. `languageServers.ruff.args`). */
+ useValue(key: string): unknown;
+ /** Stages a value; `null` removes the key on Apply. */
+ set(key: string, value: unknown): void;
+}
+
+export const SettingsFormContext = createContext<SettingsForm | null>(null);
+
+/** The form of the settings page being shown (provided by the Settings dialog). */
+export function useSettingsForm(): SettingsForm {
+ const form = useContext(SettingsFormContext);
+ if (!form) throw new Error("useSettingsForm outside a settings page");
+ return form;
}
export const useSettingsPages = create<{ pages: Map<string, SettingsPageContribution> }>(() => ({ pages: new Map() }));
@@ -684,14 +718,7 @@ export function projectViewRoots(map: ReadonlyMap<string, ProjectViewRootContrib
// in `paths[0]`, the target directory (features/templates: file templates, http-client: HTTP Request).
export type ContextMenuId =
- | "editor"
- | "projectView"
- | "editorTab"
- | "editorGutter"
- | "openIn"
- | "stopProcess"
- | "selectIn"
- | "new";
+ "editor" | "projectView" | "editorTab" | "editorGutter" | "openIn" | "stopProcess" | "selectIn" | "new";
export interface MenuGroupContext {
/** Files / directories the menu is for (absolute paths; a virtual URI for virtual documents). */
@@ -883,7 +910,9 @@ export interface RunConfigTypeContribution {
debugAdapter?: string;
}
-export const useRunConfigTypes = create<{ types: Map<string, RunConfigTypeContribution> }>(() => ({ types: new Map() }));
+export const useRunConfigTypes = create<{ types: Map<string, RunConfigTypeContribution> }>(() => ({
+ types: new Map(),
+}));
export function registerRunConfigType(type: RunConfigTypeContribution): () => void {
useRunConfigTypes.setState((s) => ({ types: new Map(s.types).set(type.id, type) }));
@@ -1019,7 +1048,11 @@ export function setLocalChanges(provider: string, lists: LocalChangelist[]): ()
}
/** Paths of the changed files, of one list (`listId`) or all; `existing` leaves out deleted files. */
-export function localChangedPaths(lists: readonly LocalChangelist[], listId?: string | null, existing = false): string[] {
+export function localChangedPaths(
+ lists: readonly LocalChangelist[],
+ listId?: string | null,
+ existing = false,
+): string[] {
const out: string[] = [];
for (const l of lists) {
if (listId && l.id !== listId) continue;
@@ -1067,7 +1100,9 @@ export function registerRunAnythingProvider(p: RunAnythingProvider): () => void
/** Registered providers in order. */
export function runAnythingProviderList(): RunAnythingProvider[] {
- return [...runAnythingProviders.values()].sort((a, b) => (a.order ?? 100) - (b.order ?? 100) || a.id.localeCompare(b.id));
+ return [...runAnythingProviders.values()].sort(
+ (a, b) => (a.order ?? 100) - (b.order ?? 100) || a.id.localeCompare(b.id),
+ );
}
// ---------------------------------------------------------------------------