LSP Downloader (#1738)

<!-- ELLIPSIS_HIDDEN -->


> [!IMPORTANT]
> This PR adds BAML CLI version management, ensuring consistent
generator versions and enabling CLI downloads with backoff logic.
> 
>   - **Behavior**:
> - Adds `get_common_generator_version()` in `baml_project/mod.rs` to
ensure all generators use the same major.minor version.
> - Implements CLI version management in `cliDownloader.ts`, including
download, extraction, and backoff logic.
> - Updates `server.ts` to handle generator version mismatches and
notify clients.
>   - **Notifications**:
> - Adds `baml_src_version` notification in `notifications.rs` to
communicate generator version to the client.
> - Handles `baml_src_generator_version` in `index.ts` to update or
restart the language server.
>   - **Misc**:
>     - Adds `semver` dependency in `Cargo.toml` for version parsing.
> - Introduces `prep-debug-download.sh` for preparing CLI binaries for
debugging.
>     - Updates `package.json` with new dependencies for CLI management.
> 
> <sup>This description was created by </sup>[<img alt="Ellipsis"
src="https://img.shields.io/badge/Ellipsis-blue?color=175173">](https://www.ellipsis.dev?ref=BoundaryML%2Fbaml&utm_source=github&utm_medium=referral)<sup>
for 25985f7. You can
[customize](https://app.ellipsis.dev/BoundaryML/settings/summaries) this
summary. It will automatically update as commits are pushed.</sup>


<!-- ELLIPSIS_HIDDEN -->

---------

Co-authored-by: Aaron Villalpando <aaron@boundaryml.com>

Author: antoniosarosi

engine/Cargo.lock

@@ -35,6 +35,7 @@ serde = { version = "1.0.197", features = ["derive"] }
 serde_json = { version = "1.0.113" }
 tracing-log = "0.2.0"
 shellexpand = { version = "3.0.0" }
+semver = "1.0.20"
 
 thiserror = { version = "2.0.0" }
 baml-log = { path = "../baml-lib/baml-log" }

engine/language_server/Cargo.toml

@@ -23,6 +23,7 @@ use lsp_types::{
     Diagnostic, DiagnosticSeverity, Hover, HoverContents, Position, Range, TextDocumentItem,
 };
 use position_utils::get_word_at_position;
+use semver::Version;
 // use rustc_hash::FxHashSet;
 use std::collections::{hash_map::DefaultHasher, HashMap};
 use std::io;
@@ -1245,6 +1246,83 @@ impl Project {
     //     self.run_generators_without_debounce(on_success, on_error)
     //         .await;
     // }
+
+    /// Checks if all generators use the same major.minor version.
+    /// Returns Ok(()) if they do (or if there are no generators),
+    /// otherwise returns an Err with a descriptive message.
+    pub fn get_common_generator_version(&self) -> Result<String, String> {
+        let runtime_version = env!("CARGO_PKG_VERSION");
+
+        let generators = match self.list_generators() {
+            Ok(gens) => gens,
+            Err(_) => return Ok(runtime_version.to_string()), // Return cargo pkg version if error listing generators
+        };
+
+        if generators.is_empty() {
+            return Ok(runtime_version.to_string());
+        }
+
+        let mut major_minor_versions = std::collections::HashMap::new();
+        let mut highest_patch_by_major_minor = std::collections::HashMap::new();
+
+        // Track major.minor versions and find highest patch for each
+        for gen in &generators {
+            if let Ok(version) = semver::Version::parse(&gen.version) {
+                let major_minor = format!("{}.{}", version.major, version.minor);
+
+                // Track generators with this major.minor
+                major_minor_versions
+                    .entry(major_minor.clone())
+                    .or_insert_with(Vec::new)
+                    .push(gen.clone());
+
+                // Track highest patch version for this major.minor
+                highest_patch_by_major_minor
+                    .entry(major_minor)
+                    .and_modify(|highest_patch: &mut u64| {
+                        if version.patch > *highest_patch {
+                            *highest_patch = version.patch;
+                        }
+                    })
+                    .or_insert(version.patch);
+            } else {
+                tracing::warn!("Invalid semver version in generator: {}", gen.version);
+                // Consider how to handle invalid versions - for now, we ignore them for the check
+            }
+        }
+
+        // If there's more than one major.minor version, return an error
+        if major_minor_versions.len() > 1 {
+            let versions_str = major_minor_versions
+                .keys()
+                .map(|v| format!("'{}'", v))
+                .collect::<Vec<_>>()
+                .join(", ");
+
+            let message = format!(
+                "Multiple generator major.minor versions detected: {}. Major and minor versions must match across all generators.",
+                versions_str
+            );
+            Err(message)
+        // If there's only one major.minor version, return it with the highest patch
+        } else if let Some((version, _)) = major_minor_versions.iter().next() {
+            if let Some(highest_patch) = highest_patch_by_major_minor.get(version) {
+                // Parse the version string to create a proper semver::Version
+                if let Ok(mut v) = Version::parse(&format!("{}.0", version)) {
+                    // Update with the highest patch version
+                    v.patch = *highest_patch;
+                    Ok(v.to_string())
+                } else {
+                    Ok(format!("{}.{}", version, highest_patch))
+                }
+            } else {
+                Ok(version.clone())
+            }
+        // Fallback to the runtime version if no valid versions were found
+        } else {
+            Err("No valid generator versions found".to_string())
+        }
+    }
 }
 
 fn get_dummy_value(

engine/language_server/src/baml_project/mod.rs

@@ -244,6 +244,51 @@ pub fn project_diagnostics(
         }
     }
 
+    // Check for generator version mismatch as well.
+    if let Err(message) = guard.get_common_generator_version() {
+        // Add the diagnostic to all generators
+        if let Ok(generators) = guard.list_generators() {
+            // Need to list generators again to get their spans
+            for gen in &generators {
+                if let Some(range) = span_to_range(
+                    &guard,
+                    &root_path,
+                    &Span {
+                        file: SourceFile::new_static(PathBuf::from(gen.span.file_path.clone()), ""),
+                        start: gen.span.start,
+                        end: gen.span.end,
+                    },
+                ) {
+                    let diagnostic = Diagnostic {
+                        range,
+                        message: message.clone(),
+                        severity: Some(DiagnosticSeverity::ERROR),
+                        source: Some("baml".to_string()),
+                        ..Default::default()
+                    };
+
+                    let span_path =
+                        ensure_absolute(&root_path, &PathBuf::from(gen.span.file_path.clone()));
+
+                    match Url::from_file_path(span_path) {
+                        Ok(uri) => {
+                            diagnostics_map
+                                .entry(uri)
+                                .or_insert_with(Vec::new)
+                                .push(diagnostic);
+                        }
+                        Err(_) => {
+                            tracing::error!(
+                                "Failed to parse URI for version mismatch diagnostic: {}",
+                                gen.span.file_path
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     diagnostics_map
 }
 

engine/language_server/src/server/api/diagnostics.rs

@@ -3,6 +3,7 @@ mod did_change;
 mod did_change_configuration;
 mod did_change_watched_files;
 // mod did_change_workspace;
+mod baml_src_version;
 mod did_close;
 mod did_open;
 mod did_save_text_document;

engine/language_server/src/server/api/notifications.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BamlSrcVersionPayload {
+    pub version: String,
+    pub root_path: String,
+}

engine/language_server/src/server/api/notifications/baml_src_version.rs

@@ -2,6 +2,7 @@ use lsp_types::notification::DidOpenTextDocument;
 use lsp_types::{DidOpenTextDocumentParams, PublishDiagnosticsParams, TextDocumentItem};
 
 use crate::server::api::diagnostics::publish_session_lsp_diagnostics;
+use crate::server::api::notifications::baml_src_version::BamlSrcVersionPayload;
 use crate::server::api::traits::{NotificationHandler, SyncNotificationHandler};
 use crate::server::api::ResultExt;
 use crate::server::client::{Notifier, Requester};
@@ -34,6 +35,28 @@ impl SyncNotificationHandler for DidOpenTextDocumentHandler {
         if project.is_none() {
             tracing::error!("Failed to get or create project for path: {:?}", file_path);
             show_err_msg!("Failed to get or create project for path: {:?}", file_path);
+        } else {
+            let project = project.unwrap();
+            let version = project.lock().unwrap().get_common_generator_version();
+            if let Ok(version) = version {
+                notifier
+                    .0
+                    .send(lsp_server::Message::Notification(
+                        lsp_server::Notification::new(
+                            "baml_src_generator_version".to_string(),
+                            BamlSrcVersionPayload {
+                                version,
+                                root_path: project
+                                    .lock()
+                                    .unwrap()
+                                    .root_path()
+                                    .to_string_lossy()
+                                    .to_string(),
+                            },
+                        ),
+                    ))
+                    .internal_error()?;
+            }
         }
         // session.open_text_document(
         //     DocumentKey::from_path(&file_path, &file_path).internal_error()?,

engine/language_server/src/server/api/notifications/did_open.rs

@@ -1,3 +1,4 @@
+use crate::server::api::notifications::baml_src_version::BamlSrcVersionPayload;
 use crate::server::api::ResultExt;
 use crate::server::client::{Notifier, Requester};
 use crate::server::Result;
@@ -27,25 +28,43 @@ impl super::SyncNotificationHandler for DidSaveTextDocument {
         session.clear_unsaved_files();
         session.reload(Some(notifier.clone())).internal_error()?;
         tracing::info!("About to run generator. URL path: {:?}", path);
-        session
+        let project = session
             .get_or_create_project(&path)
-            .expect("Ensured that a project db exists")
-            .lock()
-            .unwrap()
-            .run_generators_without_debounce(
-                |message| {
-                    tracing::info!("About to notify client that generator has run.");
-                    notifier
-                        .notify_baml_info(&format!("{}", message))
-                        .unwrap_or(())
-                },
-                |e| {
-                    tracing::error!("Error generating: {e}");
-                    notifier
-                        .notify_baml_error(&format!("Error generating: {e}"))
-                        .unwrap_or(())
-                },
-            );
+            .expect("Ensured that a project db exists");
+
+        let version = project.lock().unwrap().get_common_generator_version();
+        if let Ok(version) = version {
+            let _ = notifier.0.send(lsp_server::Message::Notification(
+                lsp_server::Notification::new(
+                    "baml_src_generator_version".to_string(),
+                    BamlSrcVersionPayload {
+                        version,
+                        root_path: project
+                            .lock()
+                            .unwrap()
+                            .root_path()
+                            .to_string_lossy()
+                            .to_string(),
+                    },
+                ),
+            ));
+        }
+
+        project.lock().unwrap().run_generators_without_debounce(
+            |message| {
+                tracing::info!("About to notify client that generator has run.");
+                notifier
+                    .notify_baml_info(&format!("{}", message))
+                    .unwrap_or(())
+            },
+            |e| {
+                tracing::error!("Error generating: {e}");
+                notifier
+                    .notify_baml_error(&format!("Error generating: {e}"))
+                    .unwrap_or(())
+            },
+        );
+
         Ok(())
     }
 }

engine/language_server/src/server/api/notifications/did_save_text_document.rs

@@ -9,7 +9,7 @@ generator lang_typescript {
   output_dir "../typescript"
   version "0.85.0"
 }
-
+ 
 
 generator lang_typescript_esm {
   output_type typescript
@@ -44,3 +44,7 @@ generator lang_go {
   version "0.85.0"
   client_package_name "example.com/integ-tests"
 }
+
+
+
+